? 该系列属于【SpringBoot基础】专栏，如您需查看其他SpringBoot相关文章，请您点击左边的连接
目录
一、初识elasticsearch
1. 安装Elasticsearch和Kibana
2. 倒排索引
3. IK分词器
4. 基础概念
二、索引库操作
1. Mapping映射属性
2. 索引库的CRUD
三、文档操作
1. 新增文档POST
2. 查询文档GET
3. 删除文档DELETE
4. 修改文档
5. 批处理
6. 总结
四、RestAPI
1. 初始化RestClient
2. 索引库操作
3. 文档操作
五、DSL查询
1. 快速入门
2. 叶子查询
3. 复合查询
4. 排序
5. 分页
（1）简单分页
（2）深度分页
6. 高亮
六、RestClient查询
1. 快速入门
（1）发送请求
（2）解析响应结果
（3）完整代码
2. 叶子查询
3. 复合查询
4. 排序和分页
5. 高亮
七、聚合
1. DSL语法
2. RestClient实现聚合
Elasticsearch结合Kibana、Logstash、Beats，是一整套技术栈，被叫做ELK。被广泛应用在日志数据分析、实时监控等领域。
一、初识elasticsearch
Elasticsearch提供核心的数据存储、搜索、分析功能的。Elasticsearch对外提供的是Restful风格的API，任何操作都可以通过发送http请求来完成。不过http请求的方式、路径、还有请求参数的格式都有严格的规范。这些规范我们肯定记不住，因此我们要借助于Kibana这个服务。
Kibana是elastic公司提供的用于操作Elasticsearch的可视化控制台。它的功能非常强大，包括：
对Elasticsearch数据的搜索、展示
对Elasticsearch数据的统计、聚合，并形成图形化报表、图形
对Elasticsearch的集群状态监控
它还提供了一个开发控制台（DevTools），在其中对Elasticsearch的Restful的API接口提供了语法提示
1. 安装Elasticsearch和Kibana
下面的Docker命令即可安装单机版本的elasticsearch：
docker run -d \ --name es \ -e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \ -e "discovery.type=single-node" \ -v es-data:/usr/share/elasticsearch/data \ -v es-plugins:/usr/share/elasticsearch/plugins \ --privileged \ --network hmall \ -p 9200:9200 \ -p 9300:9300 \ elasticsearch:7.12.1访问http://192.168.88.128:9200/，即可看到响应的Elasticsearch服务的基本信息：
下面的Docker命令，即可部署Kibana：
docker run -d \--name kibana \-e ELASTICSEARCH_HOSTS=http://es:9200 \--network=hmall \-p 5601:5601 \kibana:7.12.1安装完成后，直接访问http://192.168.88.128:5601，即可看到控制台页面：
选择Explore on my own之后，进入主页面：
然后选中Dev tools，进入开发工具页面：
2. 倒排索引
（1）正向索引
其中的id字段已经创建了索引，由于索引底层采用了B+树结构，因此我们根据id搜索的速度会非常快。
根据id精确匹配时，可以走索引，查询效率较高。而当搜索条件为模糊匹配时，由于索引无法生效，导致从索引查询退化为全表扫描，效率很差。
例如title，只在叶子节点上存在。搜索的时候只能遍历树中的每一个叶子节点，判断title数据是否符合要求。
正向索引适合于根据索引字段的精确搜索，不适合基于部分词条的模糊匹配。
而倒排索引恰好解决的就是根据部分词条模糊匹配的问题。
（2）倒排索引
倒排索引中有两个非常重要的概念：
文档（Document）：用来搜索的数据，其中的每一条数据就是一个文档。例如一个网页、一个商品信息
词条（Term）：对文档数据或用户搜索数据，利用某种算法分词，得到的具备含义的词语就是词条。例如：我是中国人，就可以分为：我、是、中国人、中国、国人这样的几个词条
流程描述：
1）用户输入条件"华为手机"进行搜索。
2）对用户输入条件分词，得到词条：华为、手机。
3）拿着词条在倒排索引中查找（由于词条有索引，查询效率很高），即可得到包含词条的文档id：1、2、3。
4）拿着文档id到正向索引中查找具体文档即可（由于id也有索引，查询效率也很高）。
（3）正向索引和倒排索引优缺点
正向索引：
优点：
可以给多个字段创建索引
根据索引字段搜索、排序速度非常快
缺点：
根据非索引字段，或者索引字段中的部分词条查找时，只能全表扫描。
倒排索引：
优点：
根据词条搜索、模糊搜索时，速度非常快
缺点：
只能给词条创建索引，而不是字段
无法根据字段做排序
3. IK分词器
Elasticsearch的关键就是倒排索引，而倒排索引依赖于对文档内容的分词，而分词则需要高效、精准的分词算法，IK分词器就是这样一个中文分词算法。
（1）安装IK分词器
在线安装
运行一个命令即可：
docker exec -it es ./bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.12.1/elasticsearch-analysis-ik-7.12.1.zip然后重启es容器：
docker restart es（2）使用IK分词器
IK分词器包含两种模式：
ik_smart：智能语义切分
ik_max_word：最细粒度切分
测试Elasticsearch官方提供的标准分词器：
POST /_analyze{ "analyzer": "standard", "text": "学习java太棒了"}语法说明：
POST：请求方式/_analyze：请求路径，这里省略了http://192.168.150.101:9200，有kibana帮我们补充analyzer：分词器类型，这里是默认的standard分词器text：要分词的内容
再测试ik_smart分词器：
POST /_analyze{ "analyzer": "ik_smart", "text": "黑马程序员学习java太棒了"} 
再测试ik_max_word分词器：
更细粒度
（3）拓展词典
随着互联网的发展，“造词运动”也越发的频繁。出现了很多新的词语，在原有的词汇列表中并不存在。比如：“泰裤辣”，“鸡你太美” 等。
想正确分词，IK分词器的词库也需要不断的更新，IK分词器提供了扩展词汇的功能。
1）打开IK分词器config目录：
如果采用在线安装的通过，默认是没有config目录的，config目录下：
2）在IKAnalyzer.cfg.xml配置文件内容添加：
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd"><properties> <comment>IK Analyzer 扩展配置</comment> <!--用户可以在这里配置自己的扩展字典 *** 添加扩展词典--> <entry key="ext_dict">ext.dic</entry></properties>3）在IK分词器的config目录新建一个 ext.dic:
4）重启elasticsearch
docker restart es4. 基础概念
（1）文档和字段
elasticsearch是面向文档（Document）存储的。
文档数据会被序列化为json格式后存储在elasticsearch中。
原本数据库中的一行数据就是ES中的一个JSON文档；而数据库中每行数据都包含很多列，这些列就转换为JSON文档中的字段（Field）。
（2）索引和映射
所有文档都散乱存放显然非常混乱，也不方便管理。要将类型相同的文档集中在一起管理，称为索引（Index）。索引就是相同类型的文档的集合。
映射（mapping）：索引中文档的字段约束信息，类似表的结构约束。
（3）mysql与elasticsearch
| MySQL | Elasticsearch | 说明 |
|---|---|---|
| Table | Index | 索引(index)，就是文档的集合，类似数据库的表(table) |
| Row | Document | 文档（Document），就是一条条的数据，类似数据库中的行（Row），文档都是JSON格式 |
| Column | Field | 字段（Field），就是JSON文档中的字段，类似数据库中的列（Column） |
| Schema | Mapping | Mapping（映射）是索引中文档的约束，例如字段类型约束。类似数据库的表结构（Schema） |
| SQL | DSL | DSL是elasticsearch提供的JSON风格的请求语句，用来操作elasticsearch，实现CRUD |
ES和Mysql两者各自有自己的擅长之处：
Mysql：擅长事务类型操作，可以确保数据的安全和一致性
Elasticsearch：擅长海量数据的搜索、分析、计算
因此在企业中，往往是两者结合使用：
对安全性要求较高的写操作，使用mysql实现
对查询性能要求较高的搜索需求，使用elasticsearch实现
二、索引库操作
1. Mapping映射属性
Mapping是对索引库中文档的约束，常见的Mapping属性包括：
type：字段数据类型，常见的简单类型有：
字符串：text（可分词的文本）、keyword（精确值，例如：品牌、国家、ip地址）
数值：long、integer、short、byte、double、float、
布尔：boolean
日期：date
对象：object
index：是否创建索引，默认为true
analyzer：使用哪种分词器
properties：该字段的子字段
例如下面的json文档：
{ "age": 21, "weight": 52.1, "isMarried": false, "info": "黑马程序员Java讲师", "email": "zy@itcast.cn", "score": [99.1, 99.5, 98.9], "name": { "firstName": "云", "lastName": "赵" }}对应的每个字段映射（Mapping）：
| 字段名 | 字段类型 | 类型说明 | 是否 参与搜索 | 是否 参与分词 | 分词器 | |
|---|---|---|---|---|---|---|
| age |
| 整数 | √ | × | —— | |
| weight |
| 浮点数 | √ | × | —— | |
| isMarried |
| 布尔 | √ | × | —— | |
| info |
| 字符串，但需要分词 | √ | √ | IK | |
| |
| 字符串，但是不分词 | × | × | —— | |
| score |
| 只看数组中元素类型 | √ | × | —— | |
| name | firstName |
| 字符串，但是不分词 | √ | × | —— |
| lastName |
| 字符串，但是不分词 | √ | × | —— |
2. 索引库的CRUD
由于Elasticsearch采用的是Restful风格的API，因此其请求方式和路径相对都比较规范，而且请求参数也都采用JSON风格。我们直接基于Kibana的DevTools来编写请求做测试，由于有语法提示，会非常方便。
（1）创建索引库和映射PUT
基本语法：
请求方式：PUT
请求路径：/索引库名，可以自定义
请求参数：mapping映射
PUT /索引库名称 #如/heima{ "mappings": { "properties": { "字段名":{ "type": "text", "analyzer": "ik_smart" }, "字段名2":{ "type": "keyword", "index": "false" }, "字段名3":{ "properties": { "子字段": { "type": "keyword" } } }, // ...略 } }}（2）查询索引库GET
基本语法：
请求方式：GET
请求路径：/索引库名
请求参数：无
GET /索引库名 #示例：GET /hmall（3）修改索引库PUT
虽然无法修改mapping中已有的字段，但是却允许添加新的字段到mapping中，因为不会对倒排索引产生影响。因此修改索引库能做的就是向索引库中添加新字段，或者更新索引库的基础属性。
示例：
PUT /heima/_mapping{ "properties": { "age":{ "type": "integer" } }}（4）删除索引库DELETE
语法：
请求方式：DELETE
请求路径：/索引库名
请求参数：无
DELETE /索引库名#示例：DELETE /heima（5）总结
索引库操作有哪些？
创建索引库：PUT /索引库名
查询索引库：GET /索引库名
删除索引库：DELETE /索引库名
修改索引库，添加字段：PUT /索引库名/_mapping
可以看到，对索引库的操作基本遵循的Restful的风格，因此API接口非常统一，方便记忆。
三、文档操作
1. 新增文档POST
语法：
POST /索引库名/_doc/文档id{ "字段1": "值1", "字段2": "值2", "字段3": { "子属性1": "值3", "子属性2": "值4" },}示例：
POST /heima/_doc/1{ "info": "黑马程序员Java讲师", "email": "zy@itcast.cn", "name": { "firstName": "云", "lastName": "赵" }}
2. 查询文档GET
根据rest风格，新增是post，查询应该是get，不过查询一般都需要条件，这里我们把文档id带上。
语法：
GET /{索引库名称}/_doc/{id}示例：
GET /heima/_doc/1查看结果：
3. 删除文档DELETE
删除使用DELETE请求，同样，需要根据id进行删除：
语法：
DELETE /{索引库名}/_doc/id值示例：
DELETE /heima/_doc/1结果：
4. 修改文档
修改有两种方式：
全量修改：直接覆盖原来的文档
局部修改：修改文档中的部分字段
（1）全量修改PUT
全量修改是覆盖原来的文档，其本质是两步操作：
根据指定的id删除文档
新增一个相同id的文档
注意：如果根据id删除时，id不存在，第二步的新增也会执行，也就从修改变成了新增操作了。先删除后增加
语法：
PUT /{索引库名}/_doc/文档id{ "字段1": "值1", "字段2": "值2", // ... 略}示例：
PUT /heima/_doc/1{ "info": "黑马程序员高级Java讲师", "email": "zy@itcast.cn", "name": { "firstName": "云", "lastName": "赵" }}由于id为1的文档已经被删除，所以第一次执行时，得到的反馈是created：
所以如果执行第2次时，得到的反馈则是updated：
（2）局部修改POST
局部修改是只修改指定id匹配的文档中的部分字段。
语法：
POST /{索引库名}/_update/文档id{ "doc": { "字段名": "新的值", }}示例：
POST /heima/_update/1{ "doc": { "email": "ZhaoYun@itcast.cn" }}执行结果：
5. 批处理
批处理采用POST请求，基本语法如下：
POST _bulk{ "index" : { "_index" : "test", "_id" : "1" } }{ "field1" : "value1" }{ "delete" : { "_index" : "test", "_id" : "2" } }{ "create" : { "_index" : "test", "_id" : "3" } }{ "field1" : "value3" }{ "update" : {"_id" : "1", "_index" : "test"} }{ "doc" : {"field2" : "value2"} }
index代表新增操作
_index：指定索引库名
_id指定要操作的文档id
{ "field1" : "value1" }：则是要新增的文档内容
delete代表删除操作
_index：指定索引库名
_id指定要操作的文档id
update代表更新操作
_index：指定索引库名
_id指定要操作的文档id
{ "doc" : {"field2" : "value2"} }：要更新的文档字段
示例，批量新增：
POST /_bulk{"index": {"_index":"heima", "_id": "3"}}{"info": "黑马程序员C++讲师", "email": "ww@itcast.cn", "name":{"firstName": "五", "lastName":"王"}}{"index": {"_index":"heima", "_id": "4"}}{"info": "黑马程序员前端讲师", "email": "zhangsan@itcast.cn", "name":{"firstName": "三", "lastName":"张"}}批量删除：
POST /_bulk{"delete":{"_index":"heima", "_id": "3"}}{"delete":{"_index":"heima", "_id": "4"}}
6. 总结
四、RestAPI
ES官方提供了各种不同语言的客户端，用来操作ES。这些客户端的本质就是组装DSL语句，通过http请求发送给ES。
1. 初始化RestClient
（1）引入依赖
在黑马上次的item-service模块（商品搜索模块）中引入es的RestHighLevelClient依赖：
<dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest-high-level-client</artifactId></dependency>因为SpringBoot默认的ES版本是7.17.10，所以我们需要覆盖默认的ES版本：
<properties> <maven.compiler.source>11</maven.compiler.source> <maven.compiler.target>11</maven.compiler.target> <elasticsearch.version>7.12.1</elasticsearch.version> </properties>（2）初始化RestHighLevelClient
RestHighLevelClient client = new RestHighLevelClient(RestClient.builder( HttpHost.create("http://192.168.88.128:9200")));（3）单元测试示例
这里为了单元测试方便，我们创建一个测试类IndexTest，然后将初始化的代码编写在@BeforeEach方法中：
public class IndexTest { private RestHighLevelClient client; @BeforeEach void setUp() { this.client = new RestHighLevelClient(RestClient.builder( HttpHost.create("http://192.168.88.128:9200") )); } @Test void testConnect() { System.out.println(client); } @AfterEach void tearDown() throws IOException { this.client.close(); }}2. 索引库操作
（1）创建索引库
Mapping映射
搜索过滤字段
分类
品牌
价格
排序字段
默认：按照更新时间降序排序
销量
价格
展示字段
商品id：用于点击后跳转
图片地址
是否是广告推广商品
名称
价格
评价数量
销量
因此，最终我们的索引库文档结构应该是这样：
index默认是true，表示要参与搜索；id虽然是bigint类型，但是通常用keyword类型
PUT /items{ "mappings": { "properties": { "id": { "type": "keyword" }, "name":{ "type": "text", "analyzer": "ik_max_word" }, "price":{ "type": "integer" }, "stock":{ "type": "integer" }, "image":{ "type": "keyword", "index": false }, "category":{ "type": "keyword" }, "brand":{ "type": "keyword" }, "sold":{ "type": "integer" }, "commentCount":{ "type": "integer", "index": false }, "isAD":{ "type": "boolean" }, "updateTime":{ "type": "date" } } }}创建索引
具体代码如下：
@Testvoid testCreateIndex() throws IOException { // 1.创建Request对象 CreateIndexRequest request = new CreateIndexRequest("items"); // 2.准备请求参数 request.source(MAPPING_TEMPLATE, XContentType.JSON); // 3.发送请求 client.indices().create(request, RequestOptions.DEFAULT);}static final String MAPPING_TEMPLATE = "{\n" + " \"mappings\": {\n" + " \"properties\": {\n" + " \"id\": {\n" + " \"type\": \"keyword\"\n" + " },\n" + " \"name\":{\n" + " \"type\": \"text\",\n" + " \"analyzer\": \"ik_max_word\"\n" + " },\n" + " \"price\":{\n" + " \"type\": \"integer\"\n" + " },\n" + " \"stock\":{\n" + " \"type\": \"integer\"\n" + " },\n" + " \"image\":{\n" + " \"type\": \"keyword\",\n" + " \"index\": false\n" + " },\n" + " \"category\":{\n" + " \"type\": \"keyword\"\n" + " },\n" + " \"brand\":{\n" + " \"type\": \"keyword\"\n" + " },\n" + " \"sold\":{\n" + " \"type\": \"integer\"\n" + " },\n" + " \"commentCount\":{\n" + " \"type\": \"integer\"\n" + " },\n" + " \"isAD\":{\n" + " \"type\": \"boolean\"\n" + " },\n" + " \"updateTime\":{\n" + " \"type\": \"date\"\n" + " }\n" + " }\n" + " }\n" + "}";
（2）删除索引库
在Request对象上。流程如下：
1）创建Request对象。这次是DeleteIndexRequest对象
2）准备参数。这里是无参，因此省略
3）发送请求。改用delete方法
@Testvoid testDeleteIndex() throws IOException { // 1.创建Request对象 DeleteIndexRequest request = new DeleteIndexRequest("items"); // 2.发送请求 client.indices().delete(request, RequestOptions.DEFAULT);}
（3）查询索引库
1）创建Request对象。这次是GetIndexRequest对象
2）准备参数。这里是无参，直接省略
3）发送请求。改用get方法
@Testvoid testExistsIndex() throws IOException { // 1.创建Request对象 GetIndexRequest request = new GetIndexRequest("items"); // 2.发送请求 client.indices().get(request, RequestOptions.DEFAULT);}3. 文档操作
（1）新增文档
语法：
思路：可以将实体类转换为json
准备实体类：
定义一个新的DTO：
@Data@ApiModel(description = "索引库实体")public class ItemDoc{ @ApiModelProperty("商品id") private String id; @ApiModelProperty("商品名称") private String name; @ApiModelProperty("价格（分）") private Integer price; @ApiModelProperty("商品图片") private String image; @ApiModelProperty("类目名称") private String category; @ApiModelProperty("品牌名称") private String brand; @ApiModelProperty("销量") private Integer sold; @ApiModelProperty("评论数") private Integer commentCount; @ApiModelProperty("是否是推广广告，true/false") private Boolean isAD; @ApiModelProperty("更新时间") private LocalDateTime updateTime;}测试：
@Testvoid testAddDocument() throws IOException { // 1.根据id查询商品数据 Item item = itemService.getById(100002644680L); // 2.转换为文档类型 ItemDoc itemDoc = BeanUtil.copyProperties(item, ItemDoc.class); // 3.将ItemDTO转json String doc = JSONUtil.toJsonStr(itemDoc); // 1.准备Request对象 IndexRequest request = new IndexRequest("items").id(itemDoc.getId()); // 2.准备Json文档 request.source(doc, XContentType.JSON); // 3.发送请求 client.index(request, RequestOptions.DEFAULT);}
（2）查询文档
@Testvoid testGetDocumentById() throws IOException { // 1.准备Request对象 GetRequest request = new GetRequest("items").id("100002644680"); // 2.发送请求 GetResponse response = client.get(request, RequestOptions.DEFAULT); // 3.获取响应结果中的source String json = response.getSourceAsString(); ItemDoc itemDoc = JSONUtil.toBean(json, ItemDoc.class); System.out.println("itemDoc= " + ItemDoc);}
（3）删除文档
@Testvoid testDeleteDocument() throws IOException { // 1.准备Request，两个参数，第一个是索引库名，第二个是文档id DeleteRequest request = new DeleteRequest("item", "100002644680"); // 2.发送请求 client.delete(request, RequestOptions.DEFAULT);}（4）修改文档
全量修改
再次写入id一样的文档，就会删除旧文档，添加新文档。与新增的JavaAPl一致。
局部修改
仅仅修改items的两个属性值
@Testvoid testUpdateDocument() throws IOException { // 1.准备Request UpdateRequest request = new UpdateRequest("items", "100002644680"); // 2.准备请求参数 request.doc( "price", 58800, "commentCount", 1 ); // 3.发送请求 client.update(request, RequestOptions.DEFAULT);}（5）批处理
批处理与前面讲的文档的CRUD步骤基本一致：
创建Request，但这次用的是BulkRequest
准备请求参数
发送请求，这次要用到client.bulk()方法
批量新增功能示例：
@Testvoid testBulk() throws IOException { // 1.创建Request BulkRequest request = new BulkRequest(); // 2.准备请求参数 request.add(new IndexRequest("items").id("1").source("json doc1", XContentType.JSON)); request.add(new IndexRequest("items").id("2").source("json doc2", XContentType.JSON)); // 3.发送请求 client.bulk(request, RequestOptions.DEFAULT);}当我们要导入商品数据时，由于商品数量达到数十万，因此不可能一次性全部导入。建议采用循环遍历方式，每次导入1000条左右的数据。
@Testvoid testLoadItemDocs() throws IOException { // 分页查询商品数据 int pageNo = 1; int size = 1000; while (true) { Page<Item> page = itemService.lambdaQuery().eq(Item::getStatus, 1).page(new Page<Item>(pageNo, size)); //查询第pageNo页 // 非空校验 List<Item> items = page.getRecords(); if (CollUtils.isEmpty(items)) { return; //退出循环条件 } log.info("加载第{}页数据，共{}条", pageNo, items.size()); // 1.创建Request BulkRequest request = new BulkRequest("items"); // 2.准备参数，添加多个新增的Request for (Item item : items) { // 2.1.转换为文档类型ItemDTO ItemDoc itemDoc = BeanUtil.copyProperties(item, ItemDoc.class); // 2.2.创建新增文档的Request对象 request.add(new IndexRequest() .id(itemDoc.getId()) .source(JSONUtil.toJsonStr(itemDoc), XContentType.JSON)); } // 3.发送请求 client.bulk(request, RequestOptions.DEFAULT); // 翻页 pageNo++; }}五、DSL查询
1. 快速入门
查询的语法结构：
GET /{索引库名}/_search{ "query": { "查询类型": { // .. 查询条件 } }}以最简单的无条件查询为例，无条件查询的类型是：match_all，因此其查询语句如下：
GET /items/_search{ "query": { "match_all": { } }}执行结果如下：
虽然是match_all，但是响应结果中并不会包含索引库中的所有文档，而是仅有10条。这是因为处于安全考虑，elasticsearch设置了默认的查询页数。
2. 叶子查询
叶子查询的类型也可以做进一步细分，常见的有：
（1）全文检索查询
以全文检索中的match为例，语法如下：
GET /{索引库名}/_search{ "query": { "match": { "字段名": "搜索条件" } }}示例：
multi_match，区别在于可以同时对多个字段搜索，而且多个字段都要满足，语法示例：
GET /{索引库名}/_search{ "query": { "multi_match": { "query": "搜索条件", "fields": ["字段1", "字段2"] } }}
（2）精确查询
精确查询，英文是Term-level query，顾名思义，词条级别的查询。也就是说不会对用户输入的搜索条件再分词，而是作为一个词条，与搜索的字段内容精确值匹配。因此推荐查找keyword、数值、日期、boolean类型的字段。
以term查询为例，其语法如下：
GET /{索引库名}/_search{ "query": { "term": { "字段名": { "value": "搜索条件" } } }}示例：
当你输入的搜索条件不是词条，而是短语时，由于不做分词，你反而搜索不到：
再来看下range查询，语法如下：
GET /{索引库名}/_search{ "query": { "range": { "字段名": { "gte": {最小值}, "lte": {最大值} } } }}range是范围查询，对于范围筛选的关键字有：
gte：大于等于
gt：大于
lte：小于等于
lt：小于
示例：
再看下ids查询：
3. 复合查询
复合查询大致可以分为两类：
第一类：基于逻辑运算组合叶子查询，实现组合条件，例如
bool
第二类：基于某种算法修改查询时的文档相关性算分，从而改变文档排名。例如：
function_score
dis_max
bool查询
bool查询，即布尔查询。就是利用逻辑运算来组合一个或多个查询子句的组合。bool查询支持的逻辑运算有：
must：必须匹配每个子查询，类似“与”
should：选择性匹配子查询，类似“或”
must_not：必须不匹配，不参与算分，类似“非”
filter：必须匹配，不参与算分
bool查询的语法如下：
GET /items/_search{ "query": { "bool": { "must": [ {"match": {"name": "手机"}} ], "should": [ {"term": {"brand": { "value": "vivo" }}}, {"term": {"brand": { "value": "小米" }}} ], "must_not": [ {"range": {"price": {"gte": 2500}}} ], "filter": [ {"range": {"price": {"lte": 1000}}} ] } }}我们要搜索手机，但品牌必须是华为，价格必须是900~1599，那么可以这样写：
GET /items/_search{ "query": { "bool": { "must": [ {"match": {"name": "手机"}} ], "filter": [ {"term": {"brand": { "value": "华为" }}}, {"range": {"price": {"gte": 90000, "lt": 159900}}} ] } }}4. 排序
elasticsearch默认是根据相关度算分（_score）来排序，但是也支持自定义方式对搜索结果排序。不过分词字段无法排序，能参与排序字段类型有：keyword类型、数值类型、地理坐标类型、日期类型等。
我们按照商品价格排序：
GET /items/_search{ "query": { "match_all": {} }, "sort": [ { "price": "desc" } ]}5. 分页
（1）简单分页
elasticsearch中通过修改from、size参数来控制要返回的分页结果：
from：从第几个文档开始
size：总共查询几个文档
类似于mysql中的limit ?, ?
GET /items/_search{ "query": { "match_all": {} }, "from": 0, // 分页开始的位置，默认为0 "size": 10, // 每页文档数量，默认10 "sort": [ { "price": { "order": "desc" } } ]}
（2）深度分页
elasticsearch的数据一般会采用分片存储，也就是把一个索引中的数据分成N份，存储到不同节点上。
这种存储方式比较有利于数据扩展，但给分页带来了一些麻烦。比如一个索引库中有100000条数据，分别存储到4个分片，每个分片25000条数据。现在每页查询10条，查询第99页。
从实现思路来分析，肯定是将所有数据排序，找出前1000名，截取其中的990~1000的部分。我们只能在每一个分片上都找出排名前1000的数据，然后汇总到一起，重新排序，才能找出整个索引库中真正的前1000名，此时截取990~1000的数据即可。
假如我们现在要查询的是第999页数据呢，是不是要找第9990~10000的数据，那岂不是需要把每个分片中的前10000名数据都查询出来，汇总在一起，在内存中排序？如果查询的分页深度更深呢，需要一次检索的数据岂不是更多？
由此可知，当查询分页深度较大时，汇总数据过多，对内存和CPU会产生非常大的压力。
因此elasticsearch会禁止from+ size 超过10000的请求。
针对深度分页，elasticsearch提供了两种解决方案：
search after：分页时需要排序，原理是从上一次的排序值开始，查询下一页数据。官方推荐使用的方式。
scroll：原理将排序后的文档id形成快照，保存下来，基于快照做分页。官方已经不推荐使用。
6. 高亮
我们在百度，京东搜索时，关键字会变成红色，比较醒目，这叫高亮显示：
观察页面源码，你会发现两件事情：
高亮词条都被加了<em>标签
<em>标签都添加了红色样式
基本语法如下：
GET /{索引库名}/_search{ "query": { "match": { "搜索字段": "搜索关键字" } }, "highlight": { "fields": { "高亮字段名称": { "pre_tags": "<em>", "post_tags": "</em>" } } }}
六、RestClient查询
1. 快速入门
（1）发送请求
（2）解析响应结果
（3）完整代码
@Testvoid testMatchAll() throws IOException { // 1.创建Request SearchRequest request = new SearchRequest("items"); // 2.组织请求参数 request.source().query(QueryBuilders.matchAllQuery()); // 3.发送请求 SearchResponse response = client.search(request, RequestOptions.DEFAULT); // 4.解析响应 handleResponse(response);}private void handleResponse(SearchResponse response) { SearchHits searchHits = response.getHits(); // 1.获取总条数 long total = searchHits.getTotalHits().value; System.out.println("共搜索到" + total + "条数据"); // 2.遍历结果数组 SearchHit[] hits = searchHits.getHits(); for (SearchHit hit : hits) { // 3.得到_source，也就是原始json文档 String source = hit.getSourceAsString(); // 4.反序列化并打印 ItemDoc item = JSONUtil.toBean(source, ItemDoc.class); System.out.println(item); }}2. 叶子查询
match查询：
@Testvoid testMatch() throws IOException { // 1.创建Request SearchRequest request = new SearchRequest("items"); // 2.组织请求参数 request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶")); // 3.发送请求 SearchResponse response = client.search(request, RequestOptions.DEFAULT); // 4.解析响应 handleResponse(response);}multi_match查询：
@Testvoid testMultiMatch() throws IOException { // 1.创建Request SearchRequest request = new SearchRequest("items"); // 2.组织请求参数 request.source().query(QueryBuilders.multiMatchQuery("脱脂牛奶", "name", "category")); // 3.发送请求 SearchResponse response = client.search(request, RequestOptions.DEFAULT); // 4.解析响应 handleResponse(response);}range查询：
@Testvoid testRange() throws IOException { // 1.创建Request SearchRequest request = new SearchRequest("items"); // 2.组织请求参数 request.source().query(QueryBuilders.rangeQuery("price").gte(10000).lte(30000)); // 3.发送请求 SearchResponse response = client.search(request, RequestOptions.DEFAULT); // 4.解析响应 handleResponse(response);}term查询：
@Testvoid testTerm() throws IOException { // 1.创建Request SearchRequest request = new SearchRequest("items"); // 2.组织请求参数 request.source().query(QueryBuilders.termQuery("brand", "华为")); // 3.发送请求 SearchResponse response = client.search(request, RequestOptions.DEFAULT); // 4.解析响应 handleResponse(response);}3. 复合查询
@Testvoid testBool() throws IOException { // 1.创建Request SearchRequest request = new SearchRequest("items"); // 2.组织请求参数 // 2.1.准备bool查询 BoolQueryBuilder bool = QueryBuilders.boolQuery(); // 2.2.关键字搜索 bool.must(QueryBuilders.matchQuery("name", "脱脂牛奶")); // 2.3.品牌过滤 bool.filter(QueryBuilders.termQuery("brand", "德亚")); // 2.4.价格过滤 bool.filter(QueryBuilders.rangeQuery("price").lte(30000)); request.source().query(bool); // 3.发送请求 SearchResponse response = client.search(request, RequestOptions.DEFAULT); // 4.解析响应 handleResponse(response);}4. 排序和分页
@Testvoid testPageAndSort() throws IOException { int pageNo = 1, pageSize = 5; // 1.创建Request SearchRequest request = new SearchRequest("items"); // 2.组织请求参数 // 2.1.搜索条件参数 request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶")); // 2.2.排序参数 request.source().sort("price", SortOrder.ASC); // 2.3.分页参数 request.source().from((pageNo - 1) * pageSize).size(pageSize); // 3.发送请求 SearchResponse response = client.search(request, RequestOptions.DEFAULT); // 4.解析响应 handleResponse(response);}5. 高亮
@Testvoid testHighlight() throws IOException { // 1.创建Request SearchRequest request = new SearchRequest("items"); // 2.组织请求参数 // 2.1.query条件 request.source().query(QueryBuilders.matchQuery("name", "脱脂牛奶")); // 2.2.高亮条件 request.source().highlighter( SearchSourceBuilder.highlight() .field("name") .preTags("<em>") .postTags("</em>") ); // 3.发送请求 SearchResponse response = client.search(request, RequestOptions.DEFAULT); // 4.解析响应 handleResponse(response);}private void handleResponse(SearchResponse response) { SearchHits searchHits = response.getHits(); // 1.获取总条数 long total = searchHits.getTotalHits().value; System.out.println("共搜索到" + total + "条数据"); // 2.遍历结果数组 SearchHit[] hits = searchHits.getHits(); for (SearchHit hit : hits) { // 3.得到_source，也就是原始json文档 String source = hit.getSourceAsString(); // 4.反序列化 ItemDoc item = JSONUtil.toBean(source, ItemDoc.class); // 5.获取高亮结果 Map<String, HighlightField> hfs = hit.getHighlightFields(); if (CollUtils.isNotEmpty(hfs)) { // 5.1.有高亮结果，获取name的高亮结果 HighlightField hf = hfs.get("name"); if (hf != null) { // 5.2.获取第一个高亮结果片段，就是商品名称的高亮值 String hfName = hf.getFragments()[0].string(); item.setName(hfName); } } System.out.println(item); }}结果：
七、聚合
聚合（aggregations）可以让我们极其方便的实现对数据的统计、分析、运算。
聚合常见的有三类：
桶（Bucket）聚合：用来对文档做分组
TermAggregation：按照文档字段值分组，例如按照品牌值分组、按照国家分组
Date Histogram：按照日期阶梯分组，例如一周为一组，或者一月为一组
度量（Metric）聚合：用以计算一些值，比如：最大值、最小值、平均值等
Avg：求平均值
Max：求最大值
Min：求最小值
Stats：同时求max、min、avg、sum等
管道（pipeline）聚合：其它聚合的结果为基础做进一步运算
1. DSL语法
（1）Bucket聚合
也就是group by category
GET /items/_search{ "size": 0, "aggs": { "category_agg": { "terms": { "field": "category", "size": 20 } } }}来看下查询的结果：
（2）带条件聚合
我想知道价格高于3000元的手机品牌有哪些，该怎么统计呢？
GET /items/_search{ "query": { "bool": { "filter": [ { "term": { "category": "手机" } }, { "range": { "price": { "gte": 300000 } } } ] } }, "size": 0, "aggs": { "brand_agg": { "terms": { "field": "brand", "size": 20 } } }}（3）Metric聚合
现在我们需要对桶内的商品做运算，获取每个品牌价格的最小值、最大值、平均值。
这就要用到Metric聚合了，例如stat聚合，就可以同时获取min、max、avg等结果。
GET /items/_search{ "query": { "bool": { "filter": [ { "term": { "category": "手机" } }, { "range": { "price": { "gte": 300000 } } } ] } }, "size": 0, "aggs": { "brand_agg": { "terms": { "field": "brand", "size": 20 }, "aggs": { "stats_meric": { "stats": { "field": "price" } } } } }}在brand_agg聚合的内部，我们新加了一个aggs参数。这个聚合就是brand_agg的子聚合，会对brand_agg形成的每个桶中的文档分别统计。
2. RestClient实现聚合
@Testvoid testAgg() throws IOException { // 1.创建Request SearchRequest request = new SearchRequest("items"); // 2.准备请求参数 BoolQueryBuilder bool = QueryBuilders.boolQuery() .filter(QueryBuilders.termQuery("category", "手机")) .filter(QueryBuilders.rangeQuery("price").gte(300000)); request.source().query(bool).size(0); // 3.聚合参数 request.source().aggregation( AggregationBuilders.terms("brand_agg").field("brand").size(5) ); // 4.发送请求 SearchResponse response = client.search(request, RequestOptions.DEFAULT); // 5.解析聚合结果 Aggregations aggregations = response.getAggregations(); // 5.1.获取品牌聚合 Terms brandTerms = aggregations.get("brand_agg"); // 5.2.获取聚合中的桶 List<? extends Terms.Bucket> buckets = brandTerms.getBuckets(); // 5.3.遍历桶内数据 for (Terms.Bucket bucket : buckets) { // 5.4.获取桶内key String brand = bucket.getKeyAsString(); System.out.print("brand = " + brand); long count = bucket.getDocCount(); System.out.println("; count = " + count); }}