Elasticsearch专栏-9.springboot集成es

pom添加依赖

        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>7.14.0</version>
        </dependency>
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.14.0</version>
        </dependency>
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-client</artifactId>
            <version>7.14.0</version>
        </dependency>

添加配置文件

package com.example.demo.config;

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;

/**
 * @description:
 * @author: junzhang
 * @time: 2022/2/18 16:50
 */
@Configuration
public class EsConfig {
    @Value("${es.hostName}")
    private String hostName;
    @Value("${es.port}")
    private Integer port;
    @Value("${es.scheme}")
    private String scheme;

    @Bean
    public RestHighLevelClient esRestClient() {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        //单机
                        new HttpHost(hostName, port, scheme)
                )
        );
        return client;
    }
/*  @Bean
    public RestHighLevelClient esRestClient() {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        //集群
                        new HttpHost("192.168.88.207", 9205, "http"),
                        new HttpHost("192.168.88.206", 9205, "http"),
                        new HttpHost("192.168.88.110", 9205, "http")
                )
        );
        return client;
    }*/
}

索引curd

创建索引

CreateIndexRequest request = new CreateIndexRequest("myindex01");
esClient.indices().create(request, RequestOptions.DEFAULT);

删除索引

DeleteIndexRequest request = new DeleteIndexRequest("myindex01");
esClient.indices().delete(request, RequestOptions.DEFAULT);

判断索引是否存在

GetIndexRequest request = new GetIndexRequest("myindex01");
boolean res = esClient.indices().exists(request, RequestOptions.DEFAULT);

文档curd

创建文档

EsUserTest user = new EsUserTest(30, "zhangjun");
IndexRequest request = new IndexRequest("myindex01");
request.id("2");
//request.timeout(TimeValue.timeValueSeconds(1));
request.source(JSON.toJSONString(user), XContentType.JSON);
IndexResponse res = esClient.index(request, RequestOptions.DEFAULT);

删除文档

DeleteRequest deleteRequest = new DeleteRequest("myindex01", "1");
DeleteResponse delete = esClient.delete(deleteRequest, RequestOptions.DEFAULT);

修改文档

EsUserTest user = new EsUserTest(40, "zhangjun");
UpdateRequest updateRequest = new UpdateRequest("myindex01", "2");
updateRequest.doc(JSON.toJSONString(user), XContentType.JSON);
esClient.update(updateRequest, RequestOptions.DEFAULT);

查询文档

GetRequest getRequest = new GetRequest("myindex01", "2");
GetResponse get = esClient.get(getRequest, RequestOptions.DEFAULT);

批量插入文档

ArrayList<EsUserTest> userArrayList = new ArrayList<>();
userArrayList.add(new EsUserTest(12, "zhangjun12"));
userArrayList.add(new EsUserTest(13, "zhangjun13"));
BulkRequest bulkRequest = new BulkRequest();
bulkRequest.timeout("10s");
//批处理请求
for (int i = 0; i < userArrayList.size(); i++) {
	bulkRequest.add(
			new IndexRequest("myindex01")
					.id("zjun" + (i + 1))
					.source(JSON.toJSONString(userArrayList.get(i)), XContentType.JSON)
	);
}
/*BulkRequest request = new BulkRequest();
request.add(new DeleteRequest("posts", "3"));
request.add(new UpdateRequest("posts", "2")
		.doc(XContentType.JSON,"other", "test"));
request.add(new IndexRequest("posts").id("4")
		.source(XContentType.JSON,"field", "baz"));*/
BulkResponse bulkResponse = esClient.bulk(bulkRequest, RequestOptions.DEFAULT);

判断文档是否存在

GetRequest getRequest = new GetRequest("myindex01", "1");
boolean res = esClient.exists(getRequest, RequestOptions.DEFAULT);

多条件查询

//1、指定索引，创建查询请求
SearchRequest request = new SearchRequest("bank");

//2、创建条件构造器
SearchSourceBuilder builder = new SearchSourceBuilder();

//3、构造条件

//查询全部
//MatchAllQueryBuilder matchQueryBuilder = QueryBuilders.matchAllQuery();
//分词查询
//MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("address", "Place National");
//多字段分词查询
//MultiMatchQueryBuilder matchQueryBuilder = QueryBuilders.multiMatchQuery("mill urie", "address", "city");
//MultiMatchQueryBuilder matchQueryBuilder = QueryBuilders.multiMatchQuery("mill Road", "address", "city").type("phrase");
//bool查询
/*BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery().must(QueryBuilders.matchQuery("gender", "M")).must(QueryBuilders.matchQuery("address", "mill"))
		.mustNot(QueryBuilders.matchQuery("age", "18")).should(QueryBuilders.matchQuery("lastname", "Wallace"));*/
/*BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery().must(QueryBuilders.matchQuery("gender", "M")).must(QueryBuilders.matchQuery("address", "mill"))
		.filter(QueryBuilders.rangeQuery("age").gte(10).lte(50)).filter(QueryBuilders.rangeQuery("balance").gte(9812).lte(9813));*/
//数值精准查询
//TermQueryBuilder queryBuilder = QueryBuilders.termQuery("age", 33);
/*BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery().should(QueryBuilders.termQuery("balance", 34487)).
		should(QueryBuilders.termQuery("balance", 29104));*/
//查询多个精确值
//TermsQueryBuilder queryBuilder = QueryBuilders.termsQuery("balance", "34487", "29104");
//TermsQueryBuilder queryBuilder = QueryBuilders.termsQuery("balance", new long[]{34487L, 29104L});
//TermsQueryBuilder queryBuilder = QueryBuilders.termsQuery("balance", new int[]{34487, 29104});
//不分词查询，有结果
//TermQueryBuilder queryBuilder = QueryBuilders.termQuery("address.keyword", "717 Hendrickson Place");
//无结果
//TermQueryBuilder queryBuilder = QueryBuilders.termQuery("address", "717 Hendrickson Place");
QueryBuilder queryBuilder = QueryBuilders.matchPhraseQuery("address", "Hutchinson Court");
//设置返回结果：分页、排序、返回部分字段等
//builder.query(matchQueryBuilder).from(0).size(5).fetchSource(new String[]{"age", "gender"}, new String[]{});
//builder.query(matchQueryBuilder).from(0).size(5).sort("age", SortOrder.DESC);
builder.query(queryBuilder);

//4、将构造好的条件放入请求中
request.source(builder);

//5、开始执行发送request请求
SearchResponse searchResponse = esClient.search(request, RequestOptions.DEFAULT);

//6、命中结果业务处理
SearchHit[] hits = searchResponse.getHits().getHits();
//总数
long total = searchResponse.getHits().getTotalHits().value;
for (SearchHit hit : hits) {
	String hitString = hit.getSourceAsString();
	System.out.println(hitString);
}

聚合查询

//1、创建查询请求，规定查询的索引
SearchRequest request = new SearchRequest("bank");
//2、创建条件构造
SearchSourceBuilder builder = new SearchSourceBuilder();
//3、查询
MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("address", "mill");
builder.query(matchQueryBuilder).size(1);
//4、聚合
AvgAggregationBuilder ageAvg = AggregationBuilders.avg("ageAvg").field("age");
MinAggregationBuilder ageMin = AggregationBuilders.min("ageMin").field("age");
MaxAggregationBuilder ageMax = AggregationBuilders.max("ageMax").field("age");
SumAggregationBuilder ageSum = AggregationBuilders.sum("ageSum").field("age");
ValueCountAggregationBuilder ageCount = AggregationBuilders.count("ageCount").field("age");
builder.aggregation(ageAvg).aggregation(ageMin).aggregation(ageMax).aggregation(ageSum).aggregation(ageCount);
//5、将构造好的条件放入请求中
request.source(builder);
//6、开始执行发送request请求
SearchResponse searchResponse = esClient.search(request, RequestOptions.DEFAULT);
//7、开始处理返回的数据
//总数
long total = searchResponse.getHits().getTotalHits().value;
System.out.println(total);
//原始数据
SearchHit[] hits = searchResponse.getHits().getHits();
List<Map<String, Object>> listMap = new ArrayList<>();
for (SearchHit hit : hits) {
	String hitString = hit.getSourceAsString();
	System.out.println(hitString);
	log.info("id:{},score:{}", hit.getId(), hit.getScore());
	listMap.add(hit.getSourceAsMap());
}
//聚合数据
Avg avgRes = searchResponse.getAggregations().get("ageAvg");
Min minRes = searchResponse.getAggregations().get("ageMin");
Max maxRes = searchResponse.getAggregations().get("ageMax");
Sum sumRes = searchResponse.getAggregations().get("ageSum");
ValueCount countRes = searchResponse.getAggregations().get("ageCount");
log.info("avg:{},min:{},max:{},sum:{},count:{}", avgRes.getValue(), minRes.getValue(), maxRes.getValue(), sumRes.getValue(), countRes.getValue());

分组查询

//1、创建查询请求，规定查询的索引
SearchRequest request = new SearchRequest("bank");
//2、创建条件构造
SearchSourceBuilder builder = new SearchSourceBuilder();
//3、构造条件
MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("address", "mill");
builder.query(matchQueryBuilder);
//分组
TermsAggregationBuilder ageGroup = AggregationBuilders.terms("ageGroup").field("age");
builder.aggregation(ageGroup);
//4、将构造好的条件放入请求中
request.source(builder);
//5、开始执行发送request请求
SearchResponse searchResponse = esClient.search(request, RequestOptions.DEFAULT);
//6、开始处理返回的数据
Terms meta = searchResponse.getAggregations().get("ageGroup");
List<? extends Terms.Bucket> buckets = meta.getBuckets();
for (Terms.Bucket bucket : buckets) {
	String key = bucket.getKeyAsString();
	long value = bucket.getDocCount();
	log.info("key:{},value:{}", key, value);
}

分组子聚合查询

//1、创建查询请求，规定查询的索引
SearchRequest request = new SearchRequest("bank");
//2、创建条件构造
SearchSourceBuilder builder = new SearchSourceBuilder();
//3、构造条件
MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("address", "mill");
builder.query(matchQueryBuilder);
//父聚合
TermsAggregationBuilder ageGroup = AggregationBuilders.terms("ageGroup").field("age");
//子聚合
AvgAggregationBuilder subAvg = AggregationBuilders.avg("ageAvg").field("age");
SumAggregationBuilder subSum = AggregationBuilders.sum("ageSum").field("age");
//设置父子顺序
ageGroup.subAggregation(subAvg).subAggregation(subSum);
builder.aggregation(ageGroup);
//4、将构造好的条件放入请求中
request.source(builder);
//5、开始执行发送request请求
SearchResponse searchResponse = esClient.search(request, RequestOptions.DEFAULT);
//6、开始处理返回的数据
Terms meta = searchResponse.getAggregations().get("ageGroup");
List<? extends Terms.Bucket> buckets = meta.getBuckets();
//meta.getBucketByKey()
for (Terms.Bucket bucket : buckets) {
	String key = bucket.getKeyAsString();
	long value = bucket.getDocCount();
	log.info("key:{},value:{}", key, value);
	Avg subavg = bucket.getAggregations().get("ageAvg");
	Sum subsum = bucket.getAggregations().get("ageSum");
	log.info("subavg:{},subsum:{}", subavg.getValue(), subsum.getValue());
}