elasticsearch入门

原创 于 2022-06-17 02:12:53 发布
· 523 阅读 · 2 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#elasticsearch #搜索引擎 #java

elasticsearch

基础

创建客户端
public class HelloElasticsearch {

	public static void main(String[] args) throws IOException {
		// 创建客户端对象
		RestHighLevelClient client = new RestHighLevelClient(
				RestClient.builder(new HttpHost("localhost", 9200, "http")));
		//		...
		System.out.println(client);

		// 关闭客户端连接
		client.close();
	}
}
创建索引
public class CreateIndex {

    public static void main(String[] args) throws IOException {
        // 创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http")));

        // 创建索引 - 请求对象
        CreateIndexRequest request = new CreateIndexRequest("user2");
        // 发送请求，获取响应
        CreateIndexResponse response = client.indices().create(request,
                RequestOptions.DEFAULT);
        boolean acknowledged = response.isAcknowledged();
        // 响应状态
        System.out.println("操作状态 = " + acknowledged);

        // 关闭客户端连接
        client.close();
    }

}
查询索引
public class SearchIndex {
    public static void main(String[] args) throws IOException {
        // 创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http")));

        // 查询索引 - 请求对象
        GetIndexRequest request = new GetIndexRequest("user2");
        // 发送请求，获取响应
        GetIndexResponse response = client.indices().get(request,
                RequestOptions.DEFAULT);
        
        System.out.println("aliases:"+response.getAliases());//别名
        System.out.println("mappings:"+response.getMappings());//映射
        System.out.println("settings:"+response.getSettings());//索引设置

        client.close();
    }
}


aliases:{user2=[]}
mappings:{user2=org.elasticsearch.cluster.metadata.MappingMetadata@ad700514}
settings:{user2={"index.creation_date":"1617948726976","index.number_of_replicas":"1","index.number_of_shards":"1","index.provided_name":"user2","index.uuid":"UGZ1ntcySnK6hWyP2qoVpQ","index.version.created":"7080099"}}

Process finished with exit code 0
删除索引
public class DeleteIndex {
    public static void main(String[] args) throws IOException {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http")));
        // 删除索引 - 请求对象
        DeleteIndexRequest request = new DeleteIndexRequest("user2");
        // 发送请求，获取响应
        AcknowledgedResponse response = client.indices().delete(request,RequestOptions.DEFAULT);
        // 操作结果
        System.out.println("操作结果 ： " + response.isAcknowledged());
        client.close();
    }
}
新增
 // 创建客户端对象
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http")));
// 新增文档 - 请求对象
IndexRequest request = new IndexRequest();
// 设置索引及唯一性标识,唯一 ID 对应一个文档document,不指定的话,es会帮我们创建一个
request.index("user").id("1001");

// 创建数据对象,就是一个document
User user = new User();
user.setName("zhangsan");
user.setAge(30);
user.setSex("男");

ObjectMapper objectMapper = new ObjectMapper();
String userJson = objectMapper.writeValueAsString(user);
// 添加文档数据，数据格式为 JSON 格式
request.source(userJson, XContentType.JSON);
// 客户端发送请求，获取响应对象
IndexResponse response = client.index(request, RequestOptions.DEFAULT);
3.打印结果信息
  System.out.println("_index:" + response.getIndex());
System.out.println("_id:" + response.getId());
System.out.println("_result:" + response.getResult());
修改
//修改文档 - 请求对象
  UpdateRequest request = new UpdateRequest();
// 配置修改参数
request.index("user").id("1001");
// 设置请求体，对数据进行修改
request.doc(XContentType.JSON, "sex", "女");
// 客户端发送请求，获取响应对象
UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
System.out.println("_index:" + response.getIndex());
System.out.println("_id:" + response.getId());
System.out.println("_result:" + response.getResult());
查询
//1.创建请求对象,根据 ID 查询
GetRequest request = new GetRequest().index("user").id("1001");
//2.客户端发送请求，获取响应对象
GetResponse response = client.get(request, RequestOptions.DEFAULT);
3.打印结果信息
System.out.println("_index:" + response.getIndex());
System.out.println("_type:" + response.getType());
System.out.println("_id:" + response.getId());
System.out.println("source:" + response.getSourceAsString());//结果

_index:user
_type:_doc
_id:1001
source:{"name":"zhangsan","age":30,"sex":"男"}

Process finished with exit code 0
删除
//创建请求对象
DeleteRequest request = new DeleteRequest().index("user").id("1001");
//客户端发送请求，获取响应对象
DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
//打印信息
System.out.println(response.toString());
批量新增
 //创建批量新增请求对象,多个操作使用and连接 
 BulkRequest request = new BulkRequest();
 request.add(new
 IndexRequest().index("user").id("1001").source(XContentType.JSON, "name",
 "zhangsan"));
 request.add(new
 IndexRequest().index("user").id("1002").source(XContentType.JSON, "name",
 "lisi"));
 request.add(new
 IndexRequest().index("user").id("1003").source(XContentType.JSON, "name",
 "wangwu"));
 //客户端发送请求，获取响应对象
 BulkResponse responses = client.bulk(request, RequestOptions.DEFAULT);
 //打印结果信息
 System.out.println("took:" + responses.getTook());
 System.out.println("items:" + responses.getItems());
批量删除
 //创建批量删除请求对象,多个操作使用and连接 
 BulkRequest request = new BulkRequest();
 request.add(new DeleteRequest().index("user").id("1001"));
 request.add(new DeleteRequest().index("user").id("1002"));
 request.add(new DeleteRequest().index("user").id("1003"));
 //客户端发送请求，获取响应对象
 BulkResponse responses = client.bulk(request, RequestOptions.DEFAULT);
 //打印结果信息
 System.out.println("took:" + responses.getTook());
 System.out.println("items:" + responses.getItems());

高级查询

制造数据
 //创建批量新增请求对象
 BulkRequest request = new BulkRequest();
 request.add(new IndexRequest().index("user").id("1001").source(XContentType.JSON, "name", "zhangsan", "age", "10", "sex","女"));
 request.add(new IndexRequest().index("user").id("1002").source(XContentType.JSON, "name", "lisi", "age", "30", "sex","女"));
 request.add(new IndexRequest().index("user").id("1003").source(XContentType.JSON, "name", "wangwu1", "age", "40", "sex","男"));
 request.add(new IndexRequest().index("user").id("1004").source(XContentType.JSON, "name", "wangwu2", "age", "20", "sex","女"));
 request.add(new IndexRequest().index("user").id("1005").source(XContentType.JSON, "name", "wangwu3", "age", "50", "sex","男"));
 request.add(new IndexRequest().index("user").id("1006").source(XContentType.JSON, "name", "wangwu4", "age", "20", "sex","男"));
 //客户端发送请求，获取响应对象
 BulkResponse responses = client.bulk(request, RequestOptions.DEFAULT);
 //打印结果信息
 System.out.println("took:" + responses.getTook());
 System.out.println("items:" + responses.getItems());
查询所有
 // 创建搜索请求对象
 SearchRequest request = new SearchRequest();
 request.indices("user");
 // 构建查询的构造器
 SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
 // 查询所有数据
 sourceBuilder.query(QueryBuilders.matchAllQuery());
 request.source(sourceBuilder);
 SearchResponse response = client.search(request, RequestOptions.DEFAULT);
 // 查询匹配
 SearchHits hits = response.getHits();
 System.out.println("took:" + response.getTook());
 System.out.println("timeout:" + response.isTimedOut());
 System.out.println("total:" + hits.getTotalHits());
 System.out.println("MaxScore:" + hits.getMaxScore());
 System.out.println("hits========>>");
 for (SearchHit hit : hits) {
 //输出每条查询的结果信息
 System.out.println(hit.getSourceAsString());
 }
 System.out.println("<<========");
条件查询
 // 创建搜索请求对象
SearchRequest request = new SearchRequest();
request.indices("user");
// 构建查询的请求体
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
sourceBuilder.query(QueryBuilders.termQuery("age", "30"));
request.source(sourceBuilder);
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 查询匹配
SearchHits hits = response.getHits();
System.out.println("took:" + response.getTook());
System.out.println("timeout:" + response.isTimedOut());
System.out.println("total:" + hits.getTotalHits());
System.out.println("MaxScore:" + hits.getMaxScore());
System.out.println("hits========>>");
for (SearchHit hit : hits) {
  //输出每条查询的结果信息
  System.out.println(hit.getSourceAsString());
}
System.out.println("<<========");

took:1ms
timeout:false
total:1 hits
MaxScore:1.0
hits========>>
{"name":"lisi","age":"30","sex":"女"}
<<========
分页查询
// 创建搜索请求对象
SearchRequest request = new SearchRequest();
request.indices("user");
// 构建查询的请求体
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
sourceBuilder.query(QueryBuilders.matchAllQuery());
// 分页查询
// 当前页起始索引(第一条数据的顺序号)， from
sourceBuilder.from(0);
// 每页显示多少条 size
sourceBuilder.size(2);
request.source(sourceBuilder);
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 查询匹配
SearchHits hits = response.getHits();
System.out.println("took:" + response.getTook());
System.out.println("timeout:" + response.isTimedOut());
System.out.println("total:" + hits.getTotalHits());
System.out.println("MaxScore:" + hits.getMaxScore());
System.out.println("hits========>>");
for (SearchHit hit : hits) {
//输出每条查询的结果信息
System.out.println(hit.getSourceAsString());
}
System.out.println("<<========");
简单排序
 // 创建搜索请求对象
 SearchRequest request = new SearchRequest();
 request.indices("user");

// 构建查询的请求体
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//指定查询条件, 全量查询
sourceBuilder.query(QueryBuilders.matchAllQuery());
// 排序
sourceBuilder.sort("age", SortOrder.ASC);
request.source(sourceBuilder);
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 查询匹配
SearchHits hits = response.getHits();
System.out.println("took:" + response.getTook());//查询时间
System.out.println("timeout:" + response.isTimedOut());
System.out.println("total:" + hits.getTotalHits());//总数
System.out.println("MaxScore:" + hits.getMaxScore());
System.out.println("hits========>>");
for (SearchHit hit : hits) {
//输出每条查询的结果信息
System.out.println(hit.getSourceAsString());
}
System.out.println("<<========");

took:1ms
timeout:false
total:6 hits
MaxScore:NaN
hits========>>
{"name":"zhangsan","age":"10","sex":"女"}
{"name":"wangwu2","age":"20","sex":"女"}
{"name":"wangwu4","age":"20","sex":"男"}
{"name":"lisi","age":"30","sex":"女"}
{"name":"wangwu1","age":"40","sex":"男"}
{"name":"wangwu3","age":"50","sex":"男"}
<<========
过滤某些字段
 // 创建搜索请求对象
 SearchRequest request = new SearchRequest();
 request.indices("user");

// 构建查询的请求体
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//指定查询条件, 全量查询
sourceBuilder.query(QueryBuilders.matchAllQuery());
// 排序
sourceBuilder.sort("age", SortOrder.ASC);


String[] includes ={"name","age"}
String[] excludes ={};
sourceBuilder.fetchSource(includes,excludes);


request.source(sourceBuilder);
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 查询匹配
SearchHits hits = response.getHits();
System.out.println("took:" + response.getTook());//查询时间
System.out.println("timeout:" + response.isTimedOut());
System.out.println("total:" + hits.getTotalHits());//总数
System.out.println("MaxScore:" + hits.getMaxScore());
System.out.println("hits========>>");
for (SearchHit hit : hits) {
//输出每条查询的结果信息
System.out.println(hit.getSourceAsString());
}
System.out.println("<<========");

took:1ms
timeout:false
total:6 hits
MaxScore:NaN
hits========>>
{"name":"zhangsan","age":"10"}
{"name":"wangwu2","age":"20"}
{"name":"wangwu4","age":"20"}
{"name":"lisi","age":"30"}
{"name":"wangwu1","age":"40"}
{"name":"wangwu3","age":"50"}
<<========
组合查询
// 创建搜索请求对象
SearchRequest request = new SearchRequest();
request.indices("user");
// 构建查询的请求体
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//组合查询
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();


// 必须包含     must:必须      matchQuery: 匹配查询
boolQueryBuilder.must(QueryBuilders.matchQuery("age", "30"));
// 一定不含			mustNot:一定不
boolQueryBuilder.mustNot(QueryBuilders.matchQuery("name", "zhangsan"));
// 或者			should:或者  就是只要满足这一条就返回
boolQueryBuilder.should(QueryBuilders.matchQuery("sex", "男"));


//构建查询
sourceBuilder.query(boolQueryBuilder);
request.source(sourceBuilder);
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 查询匹配
SearchHits hits = response.getHits();
System.out.println("took:" + response.getTook());
System.out.println("timeout:" + response.isTimedOut());
System.out.println("total:" + hits.getTotalHits());
System.out.println("MaxScore:" + hits.getMaxScore());
System.out.println("hits========>>");
for (SearchHit hit : hits) {
  //输出每条查询的结果信息
  System.out.println(hit.getSourceAsString());
}
System.out.println("<<========");
范围查询
 // 创建搜索请求对象
 SearchRequest request = new SearchRequest();
 request.indices("user");
 // 构建查询的请求体
 SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
 RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("age");
 // 大于等于
 //rangeQuery.gte("30");
 // 小于等于
 rangeQuery.lte("40");
 sourceBuilder.query(rangeQuery);
 request.source(sourceBuilder);
 SearchResponse response = client.search(request, RequestOptions.DEFAULT);
 // 查询匹配
 SearchHits hits = response.getHits();
 System.out.println("took:" + response.getTook());
 System.out.println("timeout:" + response.isTimedOut());
 System.out.println("total:" + hits.getTotalHits());
 System.out.println("MaxScore:" + hits.getMaxScore());
 System.out.println("hits========>>");
 for (SearchHit hit : hits) {
 //输出每条查询的结果信息
 System.out.println(hit.getSourceAsString());
 }
 System.out.println("<<========");
模糊查询
// 创建搜索请求对象
SearchRequest request = new SearchRequest();
request.indices("user");
// 构建查询的请求体
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//fuzzyQuery:模糊查询
//fuzziness:匹配多少字符  Fuzziness.ONE:差一个字符也可以,相当于偏差的距离
sourceBuilder.query(QueryBuilders.fuzzyQuery("name","wangwu").fuzziness(Fuzziness.ONE));
request.source(sourceBuilder);
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 查询匹配
SearchHits hits = response.getHits();
System.out.println("took:" + response.getTook());
System.out.println("timeout:" + response.isTimedOut());
System.out.println("total:" + hits.getTotalHits());
System.out.println("MaxScore:" + hits.getMaxScore());
System.out.println("hits========>>");
for (SearchHit hit : hits) {
//输出每条查询的结果信息
System.out.println(hit.getSourceAsString());
}
System.out.println("<<========");
高亮查询
 // 请求体
SearchRequest request = new SearchRequest().indices("user");
//2.创建查询请求体构建器
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//构建查询方式：高亮查询
TermsQueryBuilder termsQueryBuilder =
  QueryBuilders.termsQuery("name","zhangsan");
//设置查询方式
sourceBuilder.query(termsQueryBuilder);
//高亮构造器
//构建高亮字段
HighlightBuilder highlightBuilder = new HighlightBuilder();
highlightBuilder.preTags("<font color='red'>");//设置标签前缀
highlightBuilder.postTags("</font>");//设置标签后缀
highlightBuilder.field("name");//设置高亮字段
//设置高亮构建对象
sourceBuilder.highlighter(highlightBuilder);
//设置请求体
request.source(sourceBuilder);
//3.客户端发送请求，获取响应对象
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//4.打印响应结果
SearchHits hits = response.getHits();
System.out.println("took::"+response.getTook());
System.out.println("time_out::"+response.isTimedOut());
System.out.println("total::"+hits.getTotalHits());
System.out.println("max_score::"+hits.getMaxScore());
System.out.println("hits::::>>");
for (SearchHit hit : hits) {
  String sourceAsString = hit.getSourceAsString();
  System.out.println(sourceAsString);
  //打印高亮结果
  Map<String, HighlightField> highlightFields = hit.getHighlightFields();
  System.out.println(highlightFields);
}
System.out.println("<<::::");
聚合查询
//请求体
SearchRequest request = new SearchRequest().indices("user");
//创建查询请求体构建器
 SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//max取最大值,返回key是maxAge,字段是 age
 sourceBuilder.aggregation(AggregationBuilders.max("maxAge").field("age"));
 //设置请求体
 request.source(sourceBuilder);
 //3.客户端发送请求，获取响应对象
 SearchResponse response = client.search(request, RequestOptions.DEFAULT);
 //4.打印响应结果
 SearchHits hits = response.getHits();
 System.out.println(response);

{"took":16,"timed_out":false,"_shards":{"total":1,"successful":1,"skipped":0,"failed":0},"hits":{"total":{"value":6,"relation":"eq"},"max_score":1.0,"hits":[{"_index":"user","_type":"_doc","_id":"1001","_score":1.0,"_source":{"name":"zhangsan","age":"10","sex":"女"}},{"_index":"user","_type":"_doc","_id":"1002","_score":1.0,"_source":{"name":"lisi","age":"30","sex":"女"}},{"_index":"user","_type":"_doc","_id":"1003","_score":1.0,"_source":{"name":"wangwu1","age":"40","sex":"男"}},{"_index":"user","_type":"_doc","_id":"1004","_score":1.0,"_source":{"name":"wangwu2","age":"20","sex":"女"}},{"_index":"user","_type":"_doc","_id":"1005","_score":1.0,"_source":{"name":"wangwu3","age":"50","sex":"男"}},{"_index":"user","_type":"_doc","_id":"1006","_score":1.0,"_source":{"name":"wangwu4","age":"20","sex":"男"}}]},"aggregations":{"max#maxAge":{"value":50.0}}}

Process finished with exit code 0
分组查询
//请求体  
SearchRequest request = new SearchRequest().indices("user");
//构造器
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//aggregation聚合  terms:分组   分组 key是age_groupby  按照 age分组
sourceBuilder.aggregation(AggregationBuilders.terms("age_groupby").field("age"));
//设置请求体
request.source(sourceBuilder);
//3.客户端发送请求，获取响应对象
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//4.打印响应结果
SearchHits hits = response.getHits();
System.out.println(response);

{"took":10,"timed_out":false,"_shards":{"total":1,"successful":1,"skipped":0,"failed":0},"hits":{"total":{"value":6,"relation":"eq"},"max_score":1.0,"hits":[{"_index":"user","_type":"_doc","_id":"1001","_score":1.0,"_source":{"name":"zhangsan","age":"10","sex":"女"}},{"_index":"user","_type":"_doc","_id":"1002","_score":1.0,"_source":{"name":"lisi","age":"30","sex":"女"}},{"_index":"user","_type":"_doc","_id":"1003","_score":1.0,"_source":{"name":"wangwu1","age":"40","sex":"男"}},{"_index":"user","_type":"_doc","_id":"1004","_score":1.0,"_source":{"name":"wangwu2","age":"20","sex":"女"}},{"_index":"user","_type":"_doc","_id":"1005","_score":1.0,"_source":{"name":"wangwu3","age":"50","sex":"男"}},{"_index":"user","_type":"_doc","_id":"1006","_score":1.0,"_source":{"name":"wangwu4","age":"20","sex":"男"}}]},"aggregations":{"lterms#age_groupby":{"doc_count_error_upper_bound":0,"sum_other_doc_count":0,"buckets":[{"key":20,"doc_count":2},{"key":10,"doc_count":1},{"key":30,"doc_count":1},{"key":40,"doc_count":1},{"key":50,"doc_count":1}]}}}

Process finished with exit code 0

问题

1.SearchSourceBuilder和BoolQueryBuilder的区别?
SearchSourceBuilder是查询构造器
BoolQueryBuilder是组合查询的构造器,除此外还有RangeQueryBuilder范围查询构造器,FieldSortBuilder排序构造器
SearchSourceBuilder高级查询必须用,BoolQueryBuilder是SearchSourceBuilder的参数
2.SearchSourceBuilder还有哪些用法
//获取精准的返回条数
sourceBuilder.trackTotalHits(true);
3.FieldSortBuilder排序构造器,高级排序
//排序
FieldSortBuilder vrSortBuilder = SortBuilders.fieldSort("排序字段");
//missing 当排序字段为空或者 null是的排序方向  "_first" 或者 "_last"
vrSortBuilder.missing("_first");
//order 正常排序的方向 SortOrder.ASC或者SortOrder.DESC
vrSortBuilder.order(SortOrder.ASC);
//排序
sourceBuilder.sort(vrSortBuilder);
4.BoolQueryBuilder的 api?

BoolQueryBuilder queryBuilder= QueryBuilders.boolQuery();

1.匹配所有
queryBuilder.matchAllQuery();
2.termQuery精准匹配，大小写敏感且不支持
queryBuilder.termQuery("key", value) 					//一次匹配一个值，完全匹配
queryBuilder.termsQuery("key", obj1, obj2..)  // 一次匹配多个值
3.对中文精确匹配
queryBuilder.matchPhraseQuery("key", value)
4.单个匹配, field不支持通配符, 前缀具高级特性
queryBuilder.matchQuery(key, value);
5.匹配多个字段, field有通配符
queryBuilder.multiMatchQuery(value, key1, key2, key3);
6.组合查询
	
 queryBuilder.must(QueryBuilders.termQuery("user", "kimchy")) 			//必须满足,计算相关性分值
            .mustNot(QueryBuilders.termQuery("message", "nihao"))		//必须不匹配
            .should(QueryBuilders.termQuery("gender", "male"));			//或者,只要满足这个其它无所谓
						.filter(QueryBuilders.termQuery("user", "zzy")					//必须满足,不计算相关性分值

7.脚本查询
boolQueryBuilder.filter(QueryBuilders.scriptQuery(new Script("脚本")));
8.使用例子
1. user字段 必须存在                  boolQueryBuilder.filter(QueryBuilders.boolQuery().must(QueryBuilders.existsQuery("user")));
2. orderLogistics.sendTime的值   必须在这个范围内                  boolQueryBuilder.filter(QueryBuilders.rangeQuery("orderLogistics.sendTime").lte(LocalDateTime.now().minusDays(3)))
3. orderLogistics.signTime这个字段,一定不存在                   
boolQueryBuilder.filter(QueryBuilders.boolQuery().mustNot(QueryBuilders.existsQuery("orderLogistics.signTime")));

termQuery和matchQuery的区别

termQuery 是精准匹配
matchQuery是先分词,在匹配

must和filter的区别

must:		返回的文档必须满足must子句的条件，会计算相关性分值
filter: 返回的文档必须满足filter子句的条件。但是跟Must不一样的是，不会计算相关性分值， 并且可以使用缓存,效率高,建议使用
https://blog.youkuaiyun.com/pony_maggie/article/details/106062284
5.es返回详解
{
    "took":4,                           
    "time_out":false,				  	 
    "_shards":{    						
        "total":5,     					 
        "successful":5,  				 
        "failed":0   					
    },
    "hits":{
        "total":2,       				 
        "max_score":0.625,  			 
        "hits":[						
            {
                "_index":"books",		
                "_type":"es",     		
                "_id":"1",      		
                "_score":0.625,      	
                "_source":{			  	
                    "title":"Elasticsearch Server",
                    "publish":2013
                }
            },
            {
                "_index":"books",
                "_type":"es",
                "_id":"2",
                "_score":0.19178301,
                "_source":{
                    "title":"Mastering Elasticsearch",
                    "published":2013
                }
            }
        ]
    }
}



{
    "took":4,                    请求花了多少时间
    "time_out":false,				  	 有没有超时
    "_shards":{    						 	 执行请求时查询的分片信息
        "total":5,     					 查询的分片数量
        "successful":5,  				 成功返回结果的分片数量
        "failed":0   					   失败的分片数量
    },
    "hits":{
        "total":2,       				 		查询返回的文档总数
        "max_score":0.625,  			 	计算所得的最高分
        "hits":[						 				返回文档的hits数组,我们拿的就是这个
            {
                "_index":"books",		 	 索引
                "_type":"es",     		 属性
                "_id":"1",      		 	 标志符
                "_score":0.625,      	  得分
                "_source":{			  	  发送到索引的JSON对象
                    "title":"Elasticsearch Server",
                    "publish":2013
                }
            },
            {
                "_index":"books",
                "_type":"es",
                "_id":"2",
                "_score":0.19178301,
                "_source":{
                    "title":"Mastering Elasticsearch",
                    "published":2013
                }
            }
        ]
    }
}```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值