ES7.6基本操作以及SpringBoot整合ES7.6的API（RestHighLevelClient）_es7.6.2 resthighlevelclient

ES相关操作

# ik_smart最少切分
GET _analyze
{
  "analyzer": "ik_smart",
  "text": "河南科技大学"
}

# ik_max_word 最细粒度划分！穷尽词库所有可能
GET _analyze
{
  "analyzer": "ik_max_word",
  "text": "河南科技大学"
}

# ===================ES索引相关的基本操作=======================
# 创建索引(数据库)
# 索引库名称：csp ,文档类型名称：mytype ,文档id：1
PUT /csp/mytype/1
{
  "name":"兴趣使然的草帽路飞",
  "age":"22"
}

# 创建一个csp2索引库：
# 索引库名称：csp2
# 索引库中3个字段：name,age,birthday
# 3个字段的类型为：text,integer,date
PUT /csp2
{
  "mappings": {
    "properties": {
      "name":{
        "type": "text"
      },
      "age":{
        "type": "integer"
      },
      "birthday":{
        "type": "date"
      }
    }
  }
}

# 获得索引csp2的相关信息
GET csp2

# 创建索引csp3,文档类型使用默认的_doc,文档id：1
# 数据为：nage,age,birthday
PUT /csp3/_doc/1
{
  "name":"兴趣使然的草帽路飞",
  "age":22,
  "birthday":"1999-01-29"
}

# 查看索引csp3默认的信息
GET csp3

# 查看es健康状态
GET _cat/health

# 查看所有索引库简要信息
GET _cat/indices?v

# 修改索引csp3数据
# 修改的字段name
POST /csp3/_doc/1/_update
{
  "doc":{
    "name":"海贼王路飞"
  }
}

# 删除csp索引库
DELETE csp

# ===================ES文档相关的基本操作=======================
# 创建索引my_index，文档类型user，文档id:1
# user:1
PUT /my_index/user/1
{
  "name":"草帽路飞",
  "age":22,
  "description":"海贼王，我当定了！",
  "tags":["吃货","船长","未来的海贼王","橡胶果实能力者"]
}
# user:2
PUT /my_index/user/4
{
  "name":"海贼猎人索隆1",
  "age":22,
  "description":"背后的伤疤，是剑士的耻辱！",
  "tags":["路痴","副船长","未来的世界第一大剑豪","三刀流剑客"]
}
PUT /my_index/user/5
{
  "name":"海贼猎人索隆2",
  "age":25,
  "description":"背后的伤疤，是剑士的耻辱！",
  "tags":["路痴","副船长","未来的世界第一大剑豪","三刀流剑客"]
}
PUT /my_index/user/2
{
  "name":"海贼猎人索隆3",
  "age":24,
  "description":"背后的伤疤，是剑士的耻辱！",
  "tags":["路痴","副船长","未来的世界第一大剑豪","三刀流剑客"]
}
# user:3
PUT /my_index/user/3
{
  "name":"黑足山治",
  "age":22,
  "description":"为了天下女性而活！",
  "tags":["色胚","厨师","未来海贼王船上的初始","踢技炫酷"]
}

# 获取数据 
# 获取user:1
GET /my_index/user/1

# 搜索数据
GET /my_index/user/_search?q=name:路飞

# 搜索数据，通过json构建查询参数
# 搜索得到的结果中：
# hits: 表示索引和文档相关信息
#     "total":
#           "value": 查询到的结果的总记录数
#           "relation":  搜索结果和搜索参数的关系：eq表示相等 lt小于 gt大于
#     "_index": 表示索引名称
#     "_tyoe": 表示文档类型
#     "_id": 表示文档id
#     "_score": 表示搜索结果的权重
#     "_source": 表示文档中的数据
#             文档中数据的字段名称以及值
GET /my_index/user/_search
{
  "query": {
    "match": {
      "name": "索隆"
    }
  }
}

# 搜索数据，通过json构建查询参数，加上结果过滤
# query：构建要搜索的条件，match：构建要匹配的内容
# _source: 结果过滤，只获取name和age字段数据
# sort: 排序条件 age：要排序的字段 order:desc 降序
# from：从第几条数据开始0表示第一条，size:每页显示几条数据
GET /my_index/user/_search
{
  "query": {
    "match": {
      "name": "索隆"
    }
  },
  "_source": ["name","age"],
  "sort": [
    {
      "age": {
        "order": "desc"
      }
    }
  ],
  "from": 0,
  "size": 1
}

# 搜索数据：使用bool多条件精确查询
# 查询22岁的所有用户，且名字中带有索隆的
# bool: 多条件精确查询
#   must: [] 数组中的所有条件都需要符合  === 且and的关系
GET /my_index/user/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "age": "22"
          }
        },
        {
          "match": {
            "name": "索隆"
          }
        }
      ]
    }
  }
}

# 搜索数据：使用bool多条件精确查询
# 查询22岁的所有用户，或者名字中带有索隆的所有用户
# bool: 多条件精确查询
#   shoud: [] 数组中的所有条件只要有一个符合就行  === 或or的关系
GET /my_index/user/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "match": {
            "age": "22"
          }
        },
        {
          "match": {
            "name": "索隆"
          }
        }
      ]
    }
  }
}

# 搜索数据：使用bool多条件精确查询，filter过滤
# 查询所有用户，名字中有索隆的，且年龄在22-25之间
# bool: 多条件精确查询，filter：按照字段过滤 === gt lt eq gte大于等于 lte 小于等于
GET /my_index/user/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "name": "索隆"
          }
        }
      ],
      "filter": {
        "range": {
          "age": {
            "lt": 22,
            "gt": 25
          }
        }
      }
    }
  }
}

# 根据tags数组中的内容搜索，以空格分割查询条件
# 结果：可以得到路飞和山治的信息
GET /my_index/user/_search
{
  "query": {
    "match": {
      "tags": "厨师 船长"
    }
  }
}

# 精确查询：
# term: 精确查询，直接通过倒排索引指定的词条进行精确查找
# match: 会使用分词器解析（先分析文档，然后再通过分析的文档进行查询）
# 两个类型： text 和 keyword

# 新建一个索引
PUT my_index2
{
  "mappings": {
    "properties": {
      "name":{
        "type": "text"
      },
      "description":{
        "type": "keyword"
      }
    }
  }
}

# 向my_index2插入数据
PUT /my_index2/_doc/1
{
  "name":"蒙奇D路飞",
  "description":"海贼王我当定了！"
}

# 使用分词器查询
#  "analyzer": "keyword" 使用ik分词器查询
GET _analyze
{
  "analyzer": "keyword",
  "text": "海贼王我当定了！"
}

# 使用分词器查询
#  "analyzer": "standard" 使用默认分词器查询
# 该分词器会逐个拆分每个词（字）
GET _analyze
{
  "analyzer": "standard",
  "text": "海贼王我当定了！"
}

# term 精确查询
# 由结果得出：
# keyword类型(description)的字段不会被分词器解析
# text类型（name）的字段会被分词器解析
GET /my_index2/_search
{
  "query": {
    "term": {
      "name": {
        "value": "路"
      }
    }
  }
}

# 插入模拟数据
PUT /my_index2/_doc/3
{
  "t1":"33",
  "t2":"2020-1-17"
}
PUT /my_index2/_doc/4
{
  "t1":"44",
  "t2":"2020-1-18"
}
PUT /my_index2/_doc/5
{
  "t1":"55",
  "t2":"2020-1-19"
}
PUT /my_index2/_doc/6
{
  "t1":"66",
  "t2":"2020-1-20"
}

# 精确查询多个值
GET /my_index2/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "term": {
            "t1": {
              "value": "44"
            }
          }
        },
        {
          "term": {
            "t1": {
              "value": "55"
            }
          }
        }
      ]
    }
  }
}

# (重点)高亮查询：
# highlight：搜索结果高亮展示
#     fields：对应的字段数组
#     pre_tags: 高亮展示结果的标签前缀，默认是<em>
#     post_tags: 高亮展示结果的标签后缀，默认是</em>
GET /my_index/user/_search
{
  "query": {
    "match": {
      "name": "索隆"
    }
  },
  "highlight": {
    "pre_tags": "<p class='key' style='color:red'>",
    "post_tags": "</p>", 
    "fields": {
      "name":{}
    }
  }
}
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
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381

SpringBoot整合ES

pom.xml

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>
1
2
3
4

可以在application.yml中配置，也可以使用下面的方法配置：

ElasticSearchConfig.java

/**
 * @Auther: csp1999
 * @Date: 2020/07/11/15:16
 * @Description: ES 客户端配置
 */
@Configuration // 相当于xml 配置 bean
public class ElasticSearchConfig {

    // spring <beans id="restHighLevelClient" class="RestHighLevelClient">
    @Bean
    public RestHighLevelClient restHighLevelClient(){
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("127.0.0.1", 9200, "http")));
        return client;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

SpringBoot测试类

/**
 * @Auther: csp1999
 * @Date: 2020/07/11/15:16
 * @Description: es7.6.x客户端测试 API
 */
@SpringBootTest
class HaustEsApiApplicationTests {

    @Autowired
    @Qualifier("restHighLevelClient")
    private RestHighLevelClient client;

    /**
     * 索引的创建 Request: PUT csp_index
     *
     * @throws IOException
     */
    @Test
    void testCreateIndex() throws IOException {
        // 1.创建索引请求
        CreateIndexRequest request = new CreateIndexRequest("csp_index");
        // 2.执行创建请求 IndicesClient 请求后获得响应
        CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);

        // 输出结果
        System.out.println(createIndexResponse);// org.elasticsearch.client.indices.CreateIndexResponse@cd831c72
    }

    /**
     * 获取索引 GET
     *
     * @throws IOException
     */
    @Test
    void testExistIndex() throws IOException {
        // 1.获取索引库的请求
        GetIndexRequest request = new GetIndexRequest("csp_index");
        // 2.执行获取索引库的请求
        boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);

        // 输出结果
        System.out.println(exists);// 如果索引库存在，则输出：true，否则输出false
    }

    /**
     * 删除索引 DELETE
     *
     * @throws IOException
     */
    @Test
    void testDeleteIndex() throws IOException {
        // 1.删除索引库的请求
        DeleteIndexRequest request = new DeleteIndexRequest("csp_index");
        // 2.执行删除索引库的请求
        AcknowledgedResponse delete = client.indices().delete(request, RequestOptions.DEFAULT);

        // 输出结果
        System.out.println(delete.isAcknowledged());// 删除成功输出true，否则为false
    }

    /**
     * 添加文档
     *
     * @throws IOException
     */
    @Test
    void testAddDocument() throws IOException {
        // 1.创建对象
        User user = new User("兴趣使然的草帽路飞", 22);
        // 2.创建请求
        IndexRequest request = new IndexRequest("csp_index");

        // 3.构建请求规则：PUT /csp_index/_doc/1
        request.id("1");
        request.timeout(TimeValue.timeValueSeconds(1));
        //request.timeout("1s");

        // 4.将user对象数据放入请求,json 数据： 需要用到fastjson
        request.source(JSON.toJSONString(user), XContentType.JSON);

        // 5.客户端发送请求,获取响应的结果
        IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);

        // 输出结果
        // IndexResponse[index=csp_index,type=_doc,id=1,version=1,result=created,seqNo=0,primaryTerm=1,shards={"total":2,"successful":1,"failed":0}]
        System.out.println(indexResponse.toString());
        System.out.println(indexResponse.status());// CREATED：表示创建成功
    }

    /**
     * 获取文档,判断是否存在
     *
     * @throws IOException
     */
    @Test
    void testIsExists() throws IOException {
        // 1.判断文档是否存在的请求
        GetRequest request = new GetRequest("csp_index", "1");

        // 2.执行请求：判断文档是否存在
        boolean exists = client.exists(request, RequestOptions.DEFAULT);

        // 输出结果
        System.out.println(exists);// 存在返回true,否则返回false
    }

    /**
     * 获取文档信息
     *
     * @throws IOException
     */
    @Test
    void testGetDocument() throws IOException {
        // 1.获取文档信息的请求
        GetRequest getRequest = new GetRequest("csp_index", "1");
        // 2.执行获取文档信息的请求
        GetResponse getResponse = client.get(getRequest, RequestOptions.DEFAULT);

        // 输出结果
        System.out.println(getResponse.getSourceAsString()); //{"age":22,"name":"兴趣使然的草帽路飞"}
        System.out.println(getResponse);// 返回的全部内容和命令 是一样的：
        // {"_index":"csp_index","_type":"_doc","_id":"1","_version":1,"_seq_no":0,"_primary_term":1,"found":true,"_source":{"age":22,"name":"兴趣使然的草帽路飞"}}
    }

    /**
     * 更新文档信息
     *
     * @throws IOException
     */
    @Test
    void testUpdateDocument() throws IOException {
        // 1.更新文档请求
        UpdateRequest updateRequest = new UpdateRequest("csp_index", "1");
        // 设置请求超时时间
        updateRequest.timeout("1s");
        // user数据对象封装到json中
        User user = new User("兴趣使然的诺诺亚索隆", 23);
        updateRequest.doc(JSON.toJSONString(user), XContentType.JSON);

        // 2.执行更新文档请求
        UpdateResponse updateResponse = client.update(updateRequest, RequestOptions.DEFAULT);

        // 输出结果
        System.out.println(updateResponse.status());// OK：表示更新成功
    }

    /**
     * 删除文档记录
     *
     * @throws IOException
     */
    @Test
    void testDeleteDocument() throws IOException {
        // 1.删除文档请求
        DeleteRequest deleteRequest = new DeleteRequest("csp_index", "1");
        deleteRequest.timeout("1s");

        // 2.执行删除文档请求
        DeleteResponse deleteResponse = client.delete(deleteRequest, RequestOptions.DEFAULT);

        // 输出结果
        System.out.println(deleteResponse.status());// OK：表示删除成功
    }

    /**
     * 批量插入数据
     *
     * @throws IOException
     */
    @Test
    void testBulkRequest() throws IOException {
        // 1.批处理请求
        BulkRequest bulkRequest = new BulkRequest();
        bulkRequest.timeout("10s");

        // user数据集合
        ArrayList<User> list = new ArrayList<>();
        list.add(new User("路飞", 1));
        list.add(new User("索隆", 2));
        list.add(new User("山治", 3));
        list.add(new User("娜美", 4));
        list.add(new User("罗宾", 5));
        list.add(new User("乔巴", 6));
        list.add(new User("乌索普", 7));
        list.add(new User("弗兰奇", 8));
        list.add(new User("布鲁克", 9));
        list.add(new User("甚平", 10));

        for (int i = 0; i < list.size(); i++) {
            // 批量更新，修改，删除 都是在此进行操作
            bulkRequest.add(
                    new IndexRequest("csp_index")
                            // 批量赋值文档id： 如果不在自己赋值文档id，会默认生成随机的文档id
                            .id("" + (i + 1))
                            // ArrayList转换成json
                            .source(JSON.toJSONString(list.get(i)), XContentType.JSON)
            );
        }
        // 2.执行批量插入请求
        BulkResponse bulkResponse = client.bulk(bulkRequest, RequestOptions.DEFAULT);

        // 输出结果
        System.out.println(bulkResponse.status());// OK: 表示批量插入成功！
    }

    /**
     * ES中数据搜索:
     * SearchRequest 搜索请求
     * SearchRequest 搜索请求
     * SearchSourceBuilder 条件构造
     * HighlightBuilder 构建高亮
     * TermQueryBuilder 精确查询
     * XXXQueryBuilder 构建我们需要用到的命令
     *
     * @throws IOException
     */
    @Test
    void testSearch() throws IOException {
        // 1.创建搜索请求
        SearchRequest searchRequest = new SearchRequest("csp_index");
        // 2.构建搜索条件：条件构造器SearchSourceBuilder
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        // 高亮结果的条件构造器
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.field("name");// 要高亮的字段
        highlightBuilder.requireFieldMatch(false);// 不需要多个字段高亮，如果需要设置为true
        highlightBuilder.preTags("<span style='color:red'>");
        highlightBuilder.postTags("</span>");
        // 条件构造器，开启搜索结果高亮，并加入高亮结果的条件构造器
        sourceBuilder.highlighter(highlightBuilder);

        /**
         * 查询条件,使用QueryBuilders工具类来实现:
         *              QueryBuilders.termQuery() 精确查询
         *              QueryBuilders.matchAllQuery() 匹配所有
         */
        //TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name", "csp");// 精确查询
        //MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();// 搜索所有数据
        MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("name", "路飞");// 搜索字段name为路飞的数据

        // 查询条件（matchQueryBuilder）放入条件构造器
        sourceBuilder.query(matchQueryBuilder);

        // 条件构造器，开启分页条件: 从第1个数据开始，每页展示5条结果数据
        sourceBuilder.from(0);
        sourceBuilder.size(5);

        // 条件构造器，搜索请求超时时间60s
        sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));

        // 将条件构造器放入搜索请求
        searchRequest.source(sourceBuilder);

        // 执行搜索请求，并获得searchResponse响应
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

        // 搜索得到的所有结果都封装在hits里面,拿数据从hits里面获取
        SearchHits hits = searchResponse.getHits();
        //System.out.println(JSON.toJSONString(hits));

        // 遍历hits：解析结果，并将结果放入resultList集合
        ArrayList<Map<String, Object>> resultList = new ArrayList<>();
        for (SearchHit documentFields : searchResponse.getHits().getHits()) {
            // 获取高亮的字段
            Map<String, HighlightField> highlightFields = documentFields.getHighlightFields();
            HighlightField name = highlightFields.get("name");// 获取高亮的字段

            Map<String, Object> sourceAsMap = documentFields.getSourceAsMap();// 先获取原来未高亮的结果

            // 解析高亮的字段, 将原来未高亮的title字段换成高亮的字段
            if (name != null) {
                Text[] fragments = name.fragments();
                String newName = "";
                for (Text text : fragments) {
                    newName += text;
                }
                // 高亮字段替换原来内容
                sourceAsMap.put("name", newName);
            }
            resultList.add(documentFields.getSourceAsMap());
        }

        // 遍历resultList
        resultList.forEach(item -> {
            System.out.println(item);// {name=<span style='color:red'>路</span><span style='color:red'>飞</span>, age=1}
        });
    }
}
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
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289