1.springboot 集成elasticsearch组件

1.前置条件已经安装和搭建好了elasticsearch中间件
一：项目中引入elasticsearch相关依赖
我安装的elasticsearch版本是7.10.2 对应依赖的版本保持一致
此处省略springboot 搭建及必要的依赖项

        <dependency>
            <groupId>org.elasticsearch.clientgroupId>
            <artifactId>elasticsearch-rest-high-level-clientartifactId>
            <version>7.10.2version>
        dependency>

        <dependency>
            <groupId>org.elasticsearchgroupId>
            <artifactId>elasticsearchartifactId>
            <version>7.10.2version>
        dependency>
1
2
3
4
5
6
7
8
9
10
11

二：项目配置文件里配置上elasticsearch相关的信息
application.yml

es:
  data:
    host: ip # es安装所在的服务器ip
    port: 9200 #es对外暴露的端口
    clusterName: hc-es-cluster #es的集群
1
2
3
4
5

三：工程里编写elasticsearch相关的配置代码

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;



@Configuration
public class ESConfig {

    @Value("${es.data.host}")
    private String host;
    @Value("${es.data.clusterName}")
    private String clusterName;
    @Value("${es.data.port}")
    private Integer port;


    @Bean
    public RestHighLevelClient restHighLevelClient() {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost(host, port, "http"))
        );
        return client;
    }
}

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

四：项目中的引入和测试

import cn.hutool.json.JSONUtil;
import com.jinyi.up.user.JinyiUserProviderApplication;
import com.jinyi.up.user.esPojo.AggDimensionEnum;
import com.jinyi.up.user.esPojo.EsUser;
import com.jinyi.up.user.esPojo.EsUserSearchQueryDto;
import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.action.DocWriteRequest;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.aggregations.Aggregation;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.*;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;
import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @author huangchong
 * @date 2023/9/2 14:36
 * @desc
 */
@SpringBootTest(classes = {JinyiUserProviderApplication.class})
public class TestES {

    @Resource
    private RestHighLevelClient esClient;

    /**
     * 创建索引
     *
     * @throws IOException
     */
    @Test
    public void createIndex() throws IOException {
        //1.创建索引请求
        CreateIndexRequest request = new CreateIndexRequest("hc_index");
        //2.执行创建请求
        CreateIndexResponse indexResponse = esClient.indices().create(request, RequestOptions.DEFAULT);
        System.out.println(indexResponse);
    }

    /**
     * 获取索引 判断是否存在
     *
     * @throws IOException
     */
    @Test
    public void getIndex() throws IOException {
        //1.创建索引请求
        GetIndexRequest request = new GetIndexRequest("hc_index");
        //2.执行存在请求
        Boolean exists = esClient.indices().exists(request, RequestOptions.DEFAULT);
        System.out.println(exists);
    }

    /**
     * 删除索引
     *
     * @throws IOException
     */
    @Test
    public void deleteIndex() throws IOException {
        //1.创建索引请求
        DeleteIndexRequest request = new DeleteIndexRequest("hc_index");
        //2.执行删除请求
        AcknowledgedResponse response = esClient.indices().delete(request, RequestOptions.DEFAULT);
        System.out.println(response.isAcknowledged());
    }

    /**
     * 添加文档
     *
     * @throws IOException
     */
    @Test
    public void addEsDocument() throws IOException {
        EsUser esUser = new EsUser(1L, "hc", 32, 12, new Date());
        //1.指定索引库
        IndexRequest request = new IndexRequest("hc_index");
        // PUT /hc_index/_doc/1
        request.id("1")
                .timeout(TimeValue.timeValueSeconds(2));
        //2.将数据放入请求
        request.source(JSONUtil.toJsonStr(esUser), XContentType.JSON);
        //发送请求

        IndexResponse response = esClient.index(request, RequestOptions.DEFAULT);
        System.out.println(response.toString());
    }

    /**
     * 判断文档是否存在文档
     *
     * @throws IOException
     */
    @Test
    public void existsEsDocument() throws IOException {

        //1.指定索引库 和 查询id
        GetRequest request = new GetRequest("hc_index", "1");
        //不获取返回的_source 的上下文
        request.fetchSourceContext(new FetchSourceContext(false));
        request.storedFields("_none_");
        boolean exists = esClient.exists(request, RequestOptions.DEFAULT);
        System.out.println(exists);
    }

    /**
     * 获取文档
     *
     * @throws IOException
     */
    @Test
    public void getEsDocument() throws IOException {
        //1.指定索引库 和 查询id
        GetRequest request = new GetRequest("hc_index", "1");
        //不获取返回的_source 的上下文
        //  request.fetchSourceContext(new FetchSourceContext(false));
        //  request.storedFields("_none_");
        GetResponse getResponse = esClient.get(request, RequestOptions.DEFAULT);
        System.out.println(getResponse.toString());
        String sourceAsString = getResponse.getSourceAsString();
        System.out.println(sourceAsString); //返回全部内容 ，和命令一样
    }

    /**
     * 更新文档
     *
     * @throws IOException
     */
    @Test
    public void updateEsDocument() throws IOException {
        //1.指定索引库 和 查询id
        GetRequest request = new GetRequest("hc_index", "1");
        GetResponse getResponse = esClient.get(request, RequestOptions.DEFAULT);
        System.out.println(getResponse.toString());
        String sourceAsString = getResponse.getSourceAsString();
        EsUser esUser = JSONUtil.toBean(sourceAsString, EsUser.class);
        //1.指定索引库 和 查询id
        UpdateRequest updateRequest = new UpdateRequest("hc_index", String.valueOf(esUser.getId()));
        //不获取返回的_source 的上下文
        updateRequest.timeout(TimeValue.timeValueSeconds(2));
        esUser.setUserName("huangchong 2");
        updateRequest.doc(JSONUtil.toJsonStr(esUser), XContentType.JSON);
        UpdateResponse updateResponse = esClient.update(updateRequest, RequestOptions.DEFAULT);
        System.out.println(updateResponse.toString());
    }

    /**
     * 删除文档
     *
     * @throws IOException
     */
    @Test
    public void deleteEsDocument() throws IOException {
        //1.指定索引库 和 查询id
        DeleteRequest deleteRequest = new DeleteRequest("hc_index", "1");
        deleteRequest.timeout("1s");
        DeleteResponse delete = esClient.delete(deleteRequest, RequestOptions.DEFAULT);
        System.out.println(delete.toString());
    }


    /**
     * 批量操作
     *
     * @throws IOException
     */
    @Test
    public void bulkAddEsDocument() throws IOException {
        BulkRequest bulkRequest = new BulkRequest();
        bulkRequest.timeout("10s");
        List<EsUser> esUsers = new ArrayList<EsUser>();
        esUsers.add(new EsUser(11L, "hc1", 31, 1, new Date()));
        esUsers.add(new EsUser(17L, "hc2", 31, 1, new Date()));
        esUsers.add(new EsUser(18L, "hc3", 28, 2, new Date()));
        esUsers.add(new EsUser(19L, "hc4", 25, 2, new Date()));
        esUsers.add(new EsUser(20L, "hc5", 19, 3, new Date()));
        //批量插入
        for (int i = 0; i < esUsers.size(); i++) {
            EsUser esUser = esUsers.get(i);
            bulkRequest.add(new IndexRequest("hc_index").id(String.valueOf(esUser.getId()))
                    .source(JSONUtil.toJsonStr(esUser), XContentType.JSON).opType(DocWriteRequest.OpType.CREATE));
        }
        esClient.bulk(bulkRequest, RequestOptions.DEFAULT);
    }

    /**
     * private AggregatorFactories.Builder aggregations;
     * 1.SearchRequest 请求
     * 2.SearchSourceBuilder 条件构建
     * searchSourceBuilder.highlighter() 高亮
     *
     * @throws IOException
     */
    @Test
    public void queryEsDocument() throws IOException {
        // 1.指定索引库
        SearchRequest searchRequest = new SearchRequest("hc_index");
        //2.构建查询请求条件
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //QueryBuilders工具类 termQuery 精确查询
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("userName", "hc4");

        searchSourceBuilder.query(termQueryBuilder);
        searchSourceBuilder.timeout(TimeValue.timeValueSeconds(60L));

        searchRequest.source(searchSourceBuilder);

        SearchResponse response = esClient.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits searchHits = response.getHits();
        SearchHit[] hits = searchHits.getHits();

        for (int i = 0; i < hits.length; i++) {
            SearchHit hit = hits[i];
            String sourceAsString = hit.getSourceAsString();
            System.out.println(JSONUtil.toBean(sourceAsString, EsUser.class).toString());
        }
    }

    /**
     * private AggregatorFactories.Builder aggregations;
     * 1.SearchRequest 请求
     * 2.SearchSourceBuilder 条件构建
     * searchSourceBuilder.highlighter() 高亮
     *
     * @throws IOException
     */
    @Test
    public void aggsEsDocument() throws IOException {
        //对hc_index库的查询请求
        SearchRequest searchRequest = new SearchRequest("hc_index");
        //paramDto 转BoolQueryBuilder ：对查询条件统一封装
        EsUserSearchQueryDto queryDto = new EsUserSearchQueryDto();
        queryDto.setLikeWords("hc");
        queryDto.setUserStatus("1,2,3");
        queryDto.setAggDimensions("age");

        BoolQueryBuilder boolQueryBuilder = buildQuery(queryDto);
        //查询条件构建
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(boolQueryBuilder);
        //聚合分析无需得到分页结果，只要聚合结果就行
        buildQueryFromSize(searchSourceBuilder, 1, 0);
        //构建聚合
        aggregationsBuild(searchSourceBuilder, queryDto);
        searchRequest.source(searchSourceBuilder);
        //获取结果
        SearchResponse searchResponse = esClient.search(searchRequest, RequestOptions.DEFAULT);
        Map<String, Aggregation> aggregationMap = searchResponse.getAggregations().asMap();
        ParsedValueCount idNumAggs = (ParsedValueCount) aggregationMap.get("idNum");
        ParsedSum ageSumAggs = (ParsedSum) aggregationMap.get("ageSum");
        ParsedAvg ageAveAggs = (ParsedAvg) aggregationMap.get("ageAve");
        ParsedCardinality userNumAggs = (ParsedCardinality) aggregationMap.get("userStatusCount");

    }

    /**
     * 构建聚合方式
     */
    private void aggregationsBuild(SearchSourceBuilder sourceBuilder, EsUserSearchQueryDto queryDto) {

        ValueCountAggregationBuilder idNumAggs = AggregationBuilders.count("idNum").field("id");
        SumAggregationBuilder ageSumAggs = AggregationBuilders.sum("ageSum").field("age");
        //平均值
        AvgAggregationBuilder ageAvgAggs = AggregationBuilders.avg("ageAve").field("age");
        //统计去重后的数量
        CardinalityAggregationBuilder userStatusAggs = AggregationBuilders.cardinality("userStatusCount").field("userStatus");

        sourceBuilder.aggregation(idNumAggs);
        sourceBuilder.aggregation(ageSumAggs);
        sourceBuilder.aggregation(userStatusAggs);
        sourceBuilder.aggregation(ageAvgAggs);

        if (StringUtils.isNotEmpty(queryDto.getAggDimensions())) {
            List<String> list = Arrays.asList(queryDto.getAggDimensions().split(",")).stream().map(s -> s.trim()).collect(Collectors.toList());
            for (String dimension : list) {
                AggDimensionEnum dimensionEnum = AggDimensionEnum.getByDimension(dimension);
                if (dimension == null) {
                    continue;
                }
                TermsAggregationBuilder aggs = AggregationBuilders.terms(dimensionEnum.getDimension()).field(dimensionEnum.getField())
                        .size(10000);
                sourceBuilder.aggregation(aggs);
                aggs.subAggregation(idNumAggs);
                aggs.subAggregation(ageSumAggs);
                aggs.subAggregation(ageAvgAggs);
                aggs.subAggregation(userStatusAggs);
            }
        }
    }


    protected void buildQueryFromSize(SearchSourceBuilder sourceBuilder, Integer start, Integer size) {
        sourceBuilder.from(start);
        sourceBuilder.size(size);
    }


    /**
     * 构建查询条件
     *
     * @param queryDto
     * @return
     */
    private BoolQueryBuilder buildQuery(EsUserSearchQueryDto queryDto) {
        BoolQueryBuilder query = QueryBuilders.boolQuery();
        //搜索  分词
        if (StringUtils.isNotEmpty(queryDto.getUserName())) {
            query.must(QueryBuilders.matchQuery("userName", queryDto.getUserName()));
        }
        //匹配  包含  模糊查询
        if (StringUtils.isNotEmpty(queryDto.getLikeWords())) {
            query.must(QueryBuilders.wildcardQuery("userName", "*" + queryDto.getLikeWords() + "*"));
        }
        //订单状态  多状态 or查询
        if (StringUtils.isNotEmpty(queryDto.getUserStatus())) {
            String[] orderStatuss = StringUtils.split(queryDto.getUserStatus(), ",");
            BoolQueryBuilder orQuery = QueryBuilders.boolQuery()
                    // 多个状态查询
                    .should(QueryBuilders.termsQuery("userStatus", orderStatuss));
            query.must(orQuery);
        }
        //订单创建时间
        if (queryDto.getBeginCreateTime() != null) {
            query.must(QueryBuilders.rangeQuery("createTime").gte(queryDto.getBeginCreateTime().getTime()));
        }
        if (queryDto.getEndCreateTime() != null) {
            query.must(QueryBuilders.rangeQuery("createTime").lte(queryDto.getEndCreateTime().getTime()));
        }

        return query;
    }
}

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

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * @author huangchong
 * @date 2023/9/2 14:51
 * @desc
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
@Component
public class EsUser {

    private Long id;

    private String userName;

    private Integer age;

    private Integer userStatus;

    private Date createTime;

}
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

import lombok.Data;

import java.util.Date;

/**
 * @author huangchong
 * @date 2023/9/3 16:12
 * @desc
 */
@Data
public class EsUserSearchQueryDto {

    private Long id;

    private String userName;

    private String likeWords;

    private Integer age;
    private String userStatus;

    private Date beginCreateTime;

    private Date endCreateTime;

    private String aggDimensions;
}
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

package com.jinyi.up.user.esPojo;

import java.util.Arrays;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 聚合分析维度
 * @author huangchong
 * @date 2023/9/3 17:00
 * @desc
 */
public enum AggDimensionEnum {
    userStatus("userStatus", "userStatus", "用户状态"),
    age("age", "age", "年纪类型"),
    name("userName", "userName", "名字")
    ;

    private final String dimension;
    private final String field;
    private final String desc;

    AggDimensionEnum(String dimension, String field, String desc) {
        this.dimension = dimension;
        this.field = field;
        this.desc = desc;
    }

    public String getDesc() {
        return desc;
    }

    public String getDimension() {
        return dimension;
    }

    public String getField() {
        return field;
    }


    private static final Map<String, String> aggDimensionEnumMap = Arrays.stream(values()).collect(Collectors.toMap(AggDimensionEnum::getDimension, AggDimensionEnum::getDesc));

    public static Map<String, String> getAggDimensionEnumMap() {
        return aggDimensionEnumMap;
    }

    public static AggDimensionEnum getByDimension(String dimension) {
        for (AggDimensionEnum dimensionEnum : values()) {
            if (dimensionEnum.dimension.equals(dimension)) {
                return dimensionEnum;
            }
        }
        return null;

    }
}

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