zoukankan html css js c++ java

ElasticSearch

1.ElasticSearch安装

0.ElasticSearch安装

下载-》解压-》即用

9200为浏览器访问协议RESTful端口

9300为ElasticSearch集群间组件的通信端口

1. 可视化ElasticSearch head插件

github下载项目https://github.com/mobz/elasticsearch-head/tree/master
解压
cmd-》npm install-》npm run start运行-》通过9100端口访问

解决跨域问题：在elasticsearch.yml中配置

http.cors.enabled: true
http.cors.allow-origin: "*"

2.kibana工具下载

下载-》解压-》即用-》端口5601

汉化：kibana.yml添加

i18n.locale: "zh-CN"

3. IK分词器

下载https://github.com/medcl/elasticsearch-analysis-ik

解压到es中的插件文件夹中

重启es

闪退原因1：版本不同

闪退原因2：删除除插件以外的东西（如安装包

2.基本操作

ES是面向文档型的数据库，将ES和关系型数据库对比

2.1 索引操作

2.1.1 创建索引

PUT请求不带信息

请求:

PUT /shopping

返回结果：

{
  "acknowledged" : true, // 响应结果
  "shards_acknowledged" : true, // 分片结果
  "index" : "shopping" //索引名
}

2.1.2 查看所有索引

请求

GET /_cat/indices?v

返回结果

health status index    uuid                   pri rep docs.count docs.deleted store.size pri.store.size
yellow open   shopping nS8qJXgrTMuVVJQJEGsrrg   1   1          0            0       208b           208b

2.1.3 查看单个索引

请求

GET /shopping

结果

2.1.4删除索引

请求

DELETE /shopping

结果

{
  "acknowledged" : true
}

2.2 文档操作

2.2.1 创建文档

请求

此处发送请求的方式必须为 POST，不能是 PUT，否则会发生错误

POST /shopping/_doc{	"title": "小米手机",	"category": "小米",	"price": 3999.00}

结果

上面的数据创建后，由于没有指定数据唯一性标识（ID），默认情况下，ES 服务器会随机生成一个。

如果想要自定义唯一性标识，需要在创建时指定：

POST /shopping/_doc/1{	"title": "华为手机",	"category": "华为",	"price": 4999.00}

如果增加数据时明确数据主键，那么请求方式也可以为 PUT

2.2.2 查看文档

请求

GET /shopping/_doc/1

结果

2.2.3 修改文档

请求1(不推荐，此请求需要输入所有数据内容)

POST /shopping/_doc/1{	"title": "华为手机",	"category": "荣耀",	"price": 4900.00}

结果

请求2(推荐，可以只修改局部信息)

POST /shopping/_update/1
{
	"doc": {
		"price": 3000.00
	}
}

2.2.4 删除文档

请求

DELETE /shopping/_doc/1

结果

2.2.5 条件删除文档

请求

POST /shopping/_delete_by_query{	"query":{		"match":{			"price": 4999.00		}	}}

结果

2.3 映射操作

索引库的映射类似于关系型数据库中表的结构

2.3.1 创建映射

请求

先创建索引才能创建映射
PUT /student

PUT /student/_mapping
{
	"properties": {
		"name": {
			"type": "text",
			"index": true
		},
		"sex": {
			"type": "text",
			"index": false
		},
		"age": {
			"type": "long",
			"index": false
		}
	}
}

结果

{  "acknowledged" : true}

映射数据说明：

字段名：任意填写，下面指定许多属性，例如：title、subtitle、images、price

type：类型，Elasticsearch 中支持的数据类型非常丰富，说几个关键的：

String 类型分两种：

text：可分词

keyword：不可分词，数据会作为完整字段进行匹配

Numerical：数值类型，分两类

基本数据类型：long、integer、short、byte、double、float、half_float

浮点数的高精度类型：scaled_float

Date：日期类型

Array：数组类型

Object：对象

index：是否索引，默认为 true，也就是说你不进行任何配置，所有字段都会被索引。false：字段不会被索引，不能用来搜索

store：是否将数据进行独立存储，默认为 false。原始的文本会存储在_source 里面，默认情况下其他提取出来的字段都不是独立存储的，是从_source 里面提取出来的。当然你也可以独立的存储某个字段，只要设置"store": true 即可，获取独立存储的字段要比从_source 中解析快得多，但是也会占用更多的空间，所以要根据实际业务需求来设置。

analyzer：分词器，这里的 ik_max_word 即使用 ik 分词器

2.3.2 查看映射

请求

GET /student/_mapping

2.3.3 索引映射关系

PUT /student1{	"settings": {},	"mappings": {		"properties": {			"name": {				"type": "text",				"index": true			},			"sex": {				"type": "text",				"index": false			},			"age": {				"type": "long",				"index": false			}					}	}}

2.4 高级查询

2.4.1 查询所有文档

请求

GET /student/_search{  "query": {    "match_all": {    }  } }# "query"：这里的 query 代表一个查询对象，里面可以有不同的查询属性# "match_all"：查询类型，例如：match_all(代表查询所有)， match，term ， range 等等# {查询条件}：查询条件会根据类型的不同，写法也有差异

结果

2.4.2 匹配查询

请求

GET /student/_search
{
	"query": {
		"match": {
			"name": "zhangsan"
		}
	}
}

2.4.3 字段匹配查询

GET /student/_search{	"query": {		"multi_match": {			"query": "zhangsan",			"fields": ["name","nickname"]		}	}}

2.4.4 关键词精确查询

GET /student/_search{	"query": {		"term": {			"name": {				"value": "zhangsan"			}		}	}}

2.4.5 多关键字精确查询

GET /student/_search{	"query": {		"terms": {			"name": ["zhangsan","lisi"]		}	}}

2.4.6 指定查询字段

GET /student/_search
{
	"_source": ["name","nickname"],
	"query": {
		"terms": {
			"nickname": ["zhangsan"]
		}
	}
}

2.4.7 过滤字段

includes：来指定想要显示的字段

excludes：来指定不想要显示的字段

GET /student/_search
{
	"_source": {
		"includes": ["name","nickname"]
	},
	"query": {
		"terms": {
			"nickname": ["zhangsan"]
		}
	}
}

2.4.8 组合查询

bool把各种其它查询通过must（必须）、must_not（必须不）、should（应该）的方式进行组合

GET /student/_search{	"query": {		"bool": {			"must": [{				"match": {					"name": "zhangsan"				}			}],			"must_not": [{				"match": {					"age": "40"				}			}],			"should": [{				"match": {					"sex": "男"				}			}]		}	}}

2.4.9 范围查询

GET /student/_search{	"query": {		"range": {			"age": {				"gte": 30,				"lte": 35			}		}	}}

2.4.10 模糊查询

编辑距离是将一个术语转换为另一个术语所需的一个字符更改的次数。这些更改可以包括：更改字符（box → fox）删除字符（black → lack）插入字符（sic → sick）转置两个相邻字符（act → cat）

为了找到相似的术语，fuzzy 查询会在指定的编辑距离内创建一组搜索词的所有可能的变体或扩展。然后查询返回每个扩展的完全匹配。通过 fuzziness 修改编辑距离。一般使用默认值 AUTO，根据术语的长度生成编辑距离。

GET /student/_search
{
	"query": {
		"fuzzy": {
			"name": {
				"value": "zhangsan"
			}
		}
	}
}

也可以指定编辑距离

GET /student/_search
{
	"query": {
		"fuzzy": {
			"name": {
				"value": "zhangsan",
				"fuzziness": 2
			}
		}
	}
}

2.4.11 单字段排序

sort 可以让我们按照不同的字段进行排序，并且通过 order 指定排序的方式。desc 降序，asc升序。

GET /student/_search{	"query": {		"match_all": {}	},	"sort": [{		"age": {			"order": "desc"		}	}]}

2.4.12 多字段排序

GET /student/_search{	"query": {		"match_all": {}	},	"sort": [		{			"age": {				"order": "desc"			}		},		{			"_score": {				"order": "desc"			}		}	]}

2.4.13 高亮查询

在进行关键字搜索时，搜索出的内容中的关键字会显示不同的颜色，称之为高亮。

Elasticsearch 可以对查询内容中的关键字部分，进行标签和样式(高亮)的设置。

在使用 match 查询的同时，加上一个 highlight 属性：

pre_tags：前置标签

post_tags：后置标签

fields：需要高亮的字段

GET /student/_search
{
	"query": {
		"match": {
			"name": "zhangsan"
		}
	},
	"highlight": {
		"pre_tags": "<font color='red'>",
		"post_tags": "</font>",
		"fields": {
			"name": {}
		}
	}
}

2.4.14 分页查询

from：当前页的起始索引，默认从 0 开始。 from = (pageNum - 1) * size

size：每页显示多少条

GET /student/_search{	"query": {		"match_all": {}	},	"sort": [		{			"age": {				"order": "desc"			}		}	],	"from": 0,	"size": 2}

2.4.15 聚合查询

聚合允许使用者对 es 文档进行统计分析，类似与关系型数据库中的 group by，当然还有很多其他的聚合，例如取最大值、平均值等等。

对某个字段取最大值 max

GET /student/_search{     "aggs":{         "max_age":{         	"max":{"field":"age"}         }     },     "size":0}

对某个字段取最小值 min

GET /student/_search
{
     "aggs":{
         "min_age":{
         	"min":{"field":"age"}
         }
     },
     "size":0
}

对某个字段求和 sum

GET /student/_search
{
     "aggs":{
         "sum_age":{
         	"sum":{"field":"age"}
         }
     },
     "size":0
}

对某个字段取平均值 avg

GET /student/_search{     "aggs":{         "avg_age":{         	"avg":{"field":"age"}         }     },     "size":0}

对某个字段的值进行去重之后再取总数

GET /student/_search{     "aggs":{         "distinct_age":{         	"cardinality":{"field":"age"}         }     },     "size":0}

State 聚合

stats 聚合，对某个字段一次性返回 count，max，min，avg 和 sum 五个指标

GET /student/_search
{
     "aggs":{
         "stats_age":{
         	"stats":{"field":"age"}
         }
     },
     "size":0
}

2.4.16 桶聚合查询

桶聚和相当于 sql 中的 group by 语句

terms 聚合，分组统计

{
     "aggs":{
         "age_groupby":{
        	 "terms":{"field":"age"}
         }
     },
     "size":0
}

在 terms 分组下再进行聚合

{
     "aggs":{
         "age_groupby":{
        	 "terms":{"field":"age"}
         },
         "aggs": {
         	"sum": {"field": "age"}
         }
     },
     "size":0
}

3.Java API操作

3.1 创建Maven项目

Maven依赖

<dependencies>
        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>7.13.1</version>
        </dependency>
        <!-- elasticsearch 的客户端 -->
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.13.1</version>
        </dependency>
        <!-- elasticsearch 依赖 2.x 的 log4j -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>2.8.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.8.2</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.9</version>
        </dependency>
        <!-- junit 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

3.2 客户端对象

// 创建客户端对象
RestHighLevelClient client = new RestHighLevelClient(
RestClient.builder(new HttpHost("localhost", 9200, "http"))
);
...
// 关闭客户端连接
client.close();

注意：9200 端口为 Elasticsearch 的 Web 通信端口，localhost为启动 ES 服务的主机名

3.3 索引操作

3.3.1 创建索引

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

3.3.2 查看索引

// 查询索引 - 请求对象
GetIndexRequest request = new GetIndexRequest("user");
// 发送请求，获取响应
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());

3.3.3 删除索引

// 删除索引 - 请求对象
DeleteIndexRequest request = new DeleteIndexRequest("user");
// 发送请求，获取响应
AcknowledgedResponse response = client.indices().delete(request, 
RequestOptions.DEFAULT);
// 操作结果
System.out.println("操作结果 ： " + response.isAcknowledged());

3.4 文档操作

3.4.1 新增文档

创建数据模型

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class User {
    private String name;
    private Integer age;
    private String sex;
}

创建数据，添加到文档中

// 新增文档 - 请求对象
IndexRequest request = new IndexRequest();
// 设置索引及唯一性标识
request.index("user").id("1001");
// 创建数据对象
User user = new User();
user.setName("zhangsan");
user.setAge(30);
user.setSex("男");
ObjectMapper objectMapper = new ObjectMapper();
String productJson = objectMapper.writeValueAsString(user);
// 添加文档数据，数据格式为 JSON 格式
request.source(productJson,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());

3.4.2 修改文档

// 修改文档 - 请求对象
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());

3.4.3 查询文档

//1.创建请求对象
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());

3.4.4 删除文档

//创建请求对象
DeleteRequest request = new DeleteRequest().index("user").id("1");
//客户端发送请求，获取响应对象
DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
//打印信息
System.out.println(response.toString());

3.4.5 批量操作

//创建批量新增请求对象
BulkRequest request = new BulkRequest();
request.add(new IndexRequest().index("user").id("1001").source(XContentType.JSON, "name", "zhangsan"));
request.add(newIndexRequest().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());

//创建批量删除请求对象
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());

3.5 高级查询

3.5.1 查询所有索引数据

// 创建搜索请求对象
SearchRequest request = new SearchRequest();
request.indices("student");
// 构建查询的请求体
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("<<========");

3.5.2 term 查询，查询条件为关键字

// 创建搜索请求对象
SearchRequest request = new SearchRequest();
request.indices("student");
// 构建查询的请求体
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("<<========");

3.5.3 分页查询

// 创建搜索请求对象
SearchRequest request = new SearchRequest();
request.indices("student");
// 构建查询的请求体
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("<<========");

3.5.4 数据排序

// 构建查询的请求体
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("<<========");

3.5.5 过滤字段

// 创建搜索请求对象
SearchRequest request = new SearchRequest();
request.indices("student");
// 构建查询的请求体
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
sourceBuilder.query(QueryBuilders.matchAllQuery());
//查询字段过滤
String[] excludes = {};
String[] includes = {"name", "age"};
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("<<========");

3.5.6 Bool 查询

// 创建搜索请求对象
SearchRequest request = new SearchRequest();
request.indices("student");
// 构建查询的请求体
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
// 必须包含
boolQueryBuilder.must(QueryBuilders.matchQuery("age", "30"));
// 一定不含
boolQueryBuilder.mustNot(QueryBuilders.matchQuery("name", "zhangsan"));
// 可能包含
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("<<========");

3.5.7 范围查询

// 创建搜索请求对象
SearchRequest request = new SearchRequest();
request.indices("student");
// 构建查询的请求体
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("<<========");

3.5.8 模糊查询

// 创建搜索请求对象
SearchRequest request = new SearchRequest();
request.indices("student");
// 构建查询的请求体
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
sourceBuilder.query(QueryBuilders.fuzzyQuery("name","zhangsan").fuzziness(Fu
zziness.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("<<========");

3.5.9 高亮查询

// 高亮查询
SearchRequest request = new SearchRequest().indices("student");
//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("<<::::");

3.5.10 聚合查询

最大年龄

// 高亮查询
SearchRequest request = new SearchRequest().indices("student");
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
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);

分组统计

// 高亮查询
SearchRequest request = new SearchRequest().indices("student");
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
sourceBuilder.aggregation(AggregationBuilders.terms("age_groupby").field("ag
e"));
//设置请求体
request.source(sourceBuilder);
//3.客户端发送请求，获取响应对象
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//4.打印响应结果
SearchHits hits = response.getHits();
System.out.println(response);

查看全文

相关阅读:
MySQL版本详解
 数据库安全[一]
python itertools模块学习
 两列布局实例
 Linux 原始套接字抓包实例
 [转]Linux终端快捷键
 SQL中的LEFT JOIN 和 RIGHT JOIN 以及INNER JOIN
twisted框架入门笔记(1)
一个关于lambda的题目
 找出数组中仅仅一个出现两次的数

原文地址：https://www.cnblogs.com/lin1874/p/14848484.html