ElasticSearch之——聚合、Windows集群、JavaApi、Java代码实现增删改查

发表于 2022-02-19 更新于 2023-07-29 分类于 ElasticSearch 阅读次数：本文字数： 60k 阅读时长 ≈ 54 分钟

1.ES的聚合

聚合（aggregations）可以让我们极其方便的实现对数据的统计、分析。例如：

什么品牌的手机最受欢迎？
这些手机的平均价格、最高价格、最低价格？
这些手机每月的销售情况如何？

实现这些统计功能的比数据库的sql要方便的多，而且查询速度非常快，可以实现近实时搜索效果。

要注意：参与聚合的字段，必须不能分词。


Select * from 表名 where 分组前条件 group by 分组字段 having 分组后筛选条件
  where: 
			where用在分组前,对分组前的数据进行筛选
      where后不能使用聚合函数
	having:
			having用在分组后,对分组后的数据进行筛选
			having后可以使用聚合函数
聚合函数:
	count
  max
  min
  sum
  avg
    
根据性别分组:  group by
	男组 - 男桶
  女组 - 女桶
对分组后的数据进行聚合: 进行统计
  聚合函数 - 度量 
  聚合函数: 统计当前组中的数据信息
  度量: 测量桶中的数据信息

1.1 基本概念

Elasticsearch中的聚合，包含多种类型，最常用的两种，一个叫桶，一个叫度量：

桶（bucket）

桶的作用，是按照某种方式对数据进行分组，每一组数据在ES中称为一个桶，例如我们根据国籍对人划分，可以得到中国桶、英国桶，日本桶……或者我们按照年龄段对人进行划分：0-10,10-20,20-30,30-40等。

Elasticsearch中提供的划分桶的方式有很多：

Date Histogram Aggregation：根据日期阶梯分组，例如给定阶梯为周，会自动每周分为一组
Histogram Aggregation：根据数值阶梯分组，与日期类似，需要知道分组的间隔（interval）
Terms Aggregation：根据词条内容分组，词条内容完全匹配的为一组，类似数据库group by
Range Aggregation：数值和日期的范围分组，指定开始和结束，然后按段分组
……

综上所述，我们发现bucket aggregations 只负责对数据进行分组，并不进行计算，因此往往bucket中往往会嵌套另一种聚合：metrics aggregations即度量

度量（metrics）

分组完成以后，我们一般会对组中的数据进行聚合运算，例如求平均值、最大、最小、求和等，这些在ES中称为度量

比较常用的一些度量聚合方式：

Avg Aggregation：求平均值
Max Aggregation：求最大值
Min Aggregation：求最小值
Percentiles Aggregation：求百分比
Stats Aggregation：同时返回avg、max、min、sum、count等
Sum Aggregation：求和
Top hits Aggregation：求前几
Value Count Aggregation：求总数
……

为了测试聚合，我们先批量导入一些数据

创建索引：

PUT /car
{
  "mappings": {
    "properties": {
      "color": {
        "type": "keyword"
      },
      "make": {
        "type": "keyword"
      }
    }
  }
}

注意：在ES中，需要进行聚合、排序、过滤的字段其处理方式比较特殊，因此不能被分词，必须使用keyword或数值类型。这里我们将color和make这两个文字类型的字段设置为keyword类型，这个类型不会被分词，将来就可以参与聚合

导入数据，这里是采用批处理的API，大家直接复制到kibana运行即可：

POST /car/_bulk
{ "index": {}}
{ "price" : 10000, "color" : "红", "make" : "本田", "sold" : "2014-10-28" }
{ "index": {}}
{ "price" : 20000, "color" : "红", "make" : "本田", "sold" : "2014-11-05" }
{ "index": {}}
{ "price" : 30000, "color" : "绿", "make" : "福特", "sold" : "2014-05-18" }
{ "index": {}}
{ "price" : 15000, "color" : "蓝", "make" : "丰田", "sold" : "2014-07-02" }
{ "index": {}}
{ "price" : 12000, "color" : "绿", "make" : "丰田", "sold" : "2014-08-19" }
{ "index": {}}
{ "price" : 20000, "color" : "红", "make" : "本田", "sold" : "2014-11-05" }
{ "index": {}}
{ "price" : 80000, "color" : "红", "make" : "宝马", "sold" : "2014-01-01" }
{ "index": {}}
{ "price" : 25000, "color" : "蓝", "make" : "福特", "sold" : "2014-02-12" }

1.2 聚合为桶

首先，我们按照汽车的颜色color来划分桶，按照颜色分桶，最好是使用TermAggregation类型，按照颜色的名称来分桶。

GET /car/_search
{
    "size" : 0,
    "aggs" : { 
        "popular_colors" : { 
            "terms" : { 
              "field" : "color"
            }
        }
    }
}

size：查询条数，这里设置为0，因为我们不关心搜索到的数据，只关心聚合结果，提高效率
aggs：声明这是一个聚合查询，是aggregations的缩写
- popular_colors：给这次聚合起一个名字，可任意指定。
  - terms：聚合的类型，这里选择terms，是根据词条内容（这里是颜色）划分
    - field：划分桶时依赖的字段

结果：

{
  "took": 33,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 8,
    "max_score": 0,
    "hits": []
  },
  "aggregations": {
    "popular_colors": {
      "doc_count_error_upper_bound": 0,
      "sum_other_doc_count": 0,
      "buckets": [
        {
          "key": "红",
          "doc_count": 4
        },
        {
          "key": "绿",
          "doc_count": 2
        },
        {
          "key": "蓝",
          "doc_count": 2
        }
      ]
    }
  }
}

hits：查询结果为空，因为我们设置了size为0
aggregations：聚合的结果
popular_colors：我们定义的聚合名称
buckets：查找到的桶，每个不同的color字段值都会形成一个桶
- key：这个桶对应的color字段的值
- doc_count：这个桶中的文档数量

通过聚合的结果我们发现，目前红色的小车比较畅销！

1.3 桶内度量

前面的例子告诉我们每个桶里面的文档数量，这很有用。但通常，我们的应用需要提供更复杂的文档度量。例如，每种颜色汽车的平均价格是多少？

因此，我们需要告诉Elasticsearch使用哪个字段，使用何种度量方式进行运算，这些信息要嵌套在桶内，度量的运算会基于桶内的文档进行

现在，我们为刚刚的聚合结果添加求价格平均值的度量：

GET /car/_search
{
    "size" : 0,
    "aggs" : { 
        "popular_colors" : { 
            "terms" : { 
              "field" : "color"
            },
            "aggs":{
                "avg_price": { 
                   "avg": {
                      "field": "price" 
                   }
                }
            }
        }
    }
}

aggs：我们在上一个aggs(popular_colors)中添加新的aggs。可见度量也是一个聚合
avg_price：聚合的名称
avg：度量的类型，这里是求平均值
field：度量运算的字段

结果：

{
  "took" : 0,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 8,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [ ]
  },
  "aggregations" : {
    "popular_colors" : {
      "doc_count_error_upper_bound" : 0,
      "sum_other_doc_count" : 0,
      "buckets" : [
        {
          "key" : "红",
          "doc_count" : 4,
          "avg_price" : {
            "value" : 32500.0
          }
        },
        {
          "key" : "绿",
          "doc_count" : 2,
          "avg_price" : {
            "value" : 21000.0
          }
        },
        {
          "key" : "蓝",
          "doc_count" : 2,
          "avg_price" : {
            "value" : 20000.0
          }
        }
      ]
    }
  }
}

可以看到每个桶中都有自己的avg_price字段，这是度量聚合的结果

1.4 桶内嵌套桶

刚刚的案例中，我们在桶内嵌套度量运算。事实上桶不仅可以嵌套运算，还可以再嵌套其它桶。也就是说在每个分组中，再分更多组。

比如：我们想统计每种颜色的汽车中，分别属于哪个制造商，按照make字段再进行分桶

GET /car/_search
{
    "size" : 0,
    "aggs" : { 
        "popular_colors" : { 
            "terms" : { 
              "field" : "color"
            },
            "aggs":{
                "avg_price": { 
                   "avg": {
                      "field": "price" 
                   }
                },
                "maker":{
                    "terms":{
                        "field":"make"
                    }
                }
            }
        }
    }
}

原来的color桶和avg计算我们不变
maker：在嵌套的aggs下新添一个桶，叫做maker
terms：桶的划分类型依然是词条
filed：这里根据make字段进行划分

部分结果：

{
  "took": 16,
  "timed_out": false,
  "_shards": {
    "total": 5,
    "successful": 5,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": 8,
    "max_score": 0,
    "hits": []
  },
  "aggregations": {
    "popular_colors": {
      "doc_count_error_upper_bound": 0,
      "sum_other_doc_count": 0,
      "buckets": [
        {
          "key": "红",
          "doc_count": 4,
          "maker": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
              {
                "key": "本田",
                "doc_count": 3
              },
              {
                "key": "宝马",
                "doc_count": 1
              }
            ]
          },
          "avg_price": {
            "value": 32500
          }
        },
        {
          "key": "绿",
          "doc_count": 2,
          "maker": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
              {
                "key": "丰田",
                "doc_count": 1
              },
              {
                "key": "福特",
                "doc_count": 1
              }
            ]
          },
          "avg_price": {
            "value": 21000
          }
        },
        {
          "key": "蓝",
          "doc_count": 2,
          "maker": {
            "doc_count_error_upper_bound": 0,
            "sum_other_doc_count": 0,
            "buckets": [
              {
                "key": "丰田",
                "doc_count": 1
              },
              {
                "key": "福特",
                "doc_count": 1
              }
            ]
          },
          "avg_price": {
            "value": 20000
          }
        }
      ]
    }
  }
}

我们可以看到，新的聚合maker被嵌套在原来每一个color的桶中。
每个颜色下面都根据 make字段进行了分组
我们能读取到的信息：
- 红色车共有4辆
- 红色车的平均售价是 $32，500 美元。
- 其中3辆是 Honda 本田制造，1辆是 BMW 宝马制造。

课堂代码


GET _analyze
{
  "text": "小米手机",
  "analyzer": "ik_max_word"
}
# 排序
# 默认情况下ES会对查询结果根据评估分值进行排序
# 如果设置了排序字段则,分值失效(ES不再计算分值)
GET heima/_search
{
  "query": {
    "match": {
      "title": "小米手机"
    }
  },
  "sort": [
    {
      "price": {
        "order": "asc"
      }
    }
  ]
}

# 高亮显示
GET /heima/_search
{
  "query": {
    "match": {
      "title": "手机"
    }
  },
  "highlight": {
    "pre_tags": "<em>",
    "post_tags": "</em>", 
    "fields": {
      "title": {}
    }
  }
}
# 分页查询, 将查询结果分页展示
GET heima/_search
{
  "query": {
    "match": {
      "title": "小米手机"
    }
  },
  "size": 2
}

# bool-filter过滤
GET /heima/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "title": "小米手机"
          }
        },
        {
          "range": {
            "price": {
              "gt": 2000,
              "lt": 5200
            }
          }
        }
      ]
    }
  }
}

GET /heima/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "title": "小米手机"
          }
        }
      ],
      "filter": [
        {
          "range": {
            "price": {
              "gt": 2000,
              "lt": 3200
            }
          }
        }
      ]
    }
  }
}
# 指定查询结果字段
GET heima/_search
{
  "_source": ["title","price"], 
  "query": {
    "match": {
      "title": "小米手机"
    }
  }
}

GET heima/_search
{
  "_source": {
    "includes": ["title","price"]
  }, 
  "query": {
    "match": {
      "title": "小米手机"
    }
  }
}
GET heima/_search
{
  "_source": {
    "excludes": ["title"]
  }, 
  "query": {
    "match": {
      "title": "小米手机"
    }
  }
}
# =========================聚合
# 数据准备
PUT /car
{
  "mappings": {
    "properties": {
      "color": {
        "type": "keyword"
      },
      "make": {
        "type": "keyword"
      }
    }
  }
}
GET /car/_mapping

POST /car/_bulk
{ "index": {}}
{ "price" : 10000, "color" : "红", "make" : "本田", "sold" : "2014-10-28" }
{ "index": {}}
{ "price" : 20000, "color" : "红", "make" : "本田", "sold" : "2014-11-05" }
{ "index": {}}
{ "price" : 30000, "color" : "绿", "make" : "福特", "sold" : "2014-05-18" }
{ "index": {}}
{ "price" : 15000, "color" : "蓝", "make" : "丰田", "sold" : "2014-07-02" }
{ "index": {}}
{ "price" : 12000, "color" : "绿", "make" : "丰田", "sold" : "2014-08-19" }
{ "index": {}}
{ "price" : 20000, "color" : "红", "make" : "本田", "sold" : "2014-11-05" }
{ "index": {}}
{ "price" : 80000, "color" : "红", "make" : "宝马", "sold" : "2014-01-01" }
{ "index": {}}
{ "price" : 25000, "color" : "蓝", "make" : "福特", "sold" : "2014-02-12" }

# ===========
GET /car/_search
{
  "query": {
    "match_all": {}
  }
}
# 聚合分桶
GET car/_search
{
  "query": {
    "term": {
      "make": "福特"
    }
  },
  "size": 0,
  "aggs": {
    "aaa": {
      "terms": {
        "field": "color"
      }
    }
  }
}
# 分完桶后,对桶中的数据进行度量
# 求每一个桶中汽车价格的平均值(度量本质上也是聚合)
GET car/_search
{
  "size": 0,
  "aggs": {
    "colors_name": {
      "terms": {
        "field": "color"
      },
      "aggs": {
        "avg_name": {
          "avg":{
            "field": "price"
          }
        },
        "max_name":{
          "max": {
            "field": "price"
          }
        }
      }
    }
  }
}


GET car/_search
{
  "size": 0,
  "aggs": {
    "colors_name": {
      "terms": {
        "field": "color"
      },
      "aggs": {
        "make_name": {
          "terms": {
            "field": "make"
          },
          "aggs": {
            "max_name": {
              "max": {
                "field": "price"
              }
            }
          }
        },
        "min_name":{
          "min": {
            "field": "price"
          }
        }
      }
    }
  }
}

2.ES集群

我们之前安装的是单机的ES，线上部署肯定不能只用一台，因为一旦服务宕机，整个搜索服务就不可用了。因此必须使用集群来解决。

那么问题来了：什么是集群呢？

2.1.什么是集群

来看下维基百科对集群的介绍：

1543286678122

集群是==一组计算机==高度紧密协作，完成计算工作。其中的每个计算机称为一个==节点==。根据这些计算机的协作方式不同或者目的不同，我们将集群分成三类：

高可用集群
负载均衡集群
科学计算集群（分布式处理）

上述几种集群方式并非必须独立使用，我们在系统架构时经常会组合使用。

2.1.1 高可用集群

High availability Cluster高可用群集，简称HAC。其设计思想是为了避免出现单点故障问题，在故障时可以==快速恢复，快速继续提供服务==。

1543287433625

如图所示，集群中两台计算机node01和node02，两者共享资源，处理业务也基本一致，互为==主从==。当node01工作时，node02就处于待命状态。所有业务在Node01上运行，若发生故障服务和资源会转移到Node02上。

这种架构保证了服务的高可用，但是闲置的节点是对资源的一种浪费。

2.1.2 负载均衡集群

Load Balancing负载均衡，集群中的每一台计算机都来完成相同业务，不分主次。当用户请求到达时，通过某种算法，让请求均衡的分发到集群中的每个节点，充分利用每个节点的资源。如图所示：

1543287806342

因为每个节点业务相同，如果某个节点出现故障，只需要把请求分发到其它节点即可。

2.1.3 科学计算集群

因为硬件设备的限制，单台计算机的处理性能是有上限的，如果计算需要的资源超过了单台计算机的能力，该怎么办呢？此时就可以使用科学计算集群。

我们把复杂任务拆分成一个个小的子任务，然后分配到集群中的不同节点上完成，最后再把计算结果汇总。这样大量低廉的PC机互联起来，组成一个”超级计算机”以解决复杂的计算任务。

1543288401040

这样的方式也称为==分布式运算或者分布式集群==，集群中的每个节点完成==不同任务==。

2.2.WEB应用的集群模式

上述计算机协作的集群方式任何领域都可以使用，在web开发中也是如此，不过有一些细节的不同。我们以一个电商网站为例，看看几种架构方式：

2.2.1 单体应用

所有业务在一个系统中完成：

出现的问题：

系统庞大，功能耦合，难以维护
并发能力差，容易出现单点故障
无法针对不同功能进行优化

2.2.2 分布式架构

按照上面的分布式集群概念，集群中的每个节点完成不同业务。在web开发中也是如此，我们把完整系统进行拆分，形成独立系统，然后部署到不同的tomcat节点，不同节点通过网络通信，相互协作。

这样就将复杂系统细分，降低了业务间的耦合，但是却带来了另一个问题，就是单个节点故障会导致整个系统不完整。为了保证高可用，还需要对集群做备份，实现负载均衡。

2.2.3 高可用分布式集群架构

为了解决上面所述的单点故障问题，我们可以为分布式系统中的每个节点都部署负载均衡节点，即：每个业务系统都有一个负载均衡的小集群。

2.3.ElasticSearch的集群

单点的elasticsearch存在哪些可能出现的问题呢？

单台机器存储容量有限
单服务器容易出现单点故障，无法实现高可用
单服务的并发处理能力有限

所以，为了应对这些问题，我们需要对elasticsearch搭建集群

2.3.1.数据分片

首先，我们面临的第一个问题就是数据量太大，单点存储量有限的问题。

我们可以把数据拆分成多份，每一份存储到不同机器节点（node），从而实现减少每个节点数据量的目的。这就是数据的分布式存储，也叫做：数据分片（Shard）。

此处，我们把数据分成3片：shard0、shard1、shard2

2.3.2.数据备份

数据分片解决了海量数据存储的问题，但是如果出现单点故障，那么分片数据就不再完整，这又该如何解决呢？

没错，就像大家为了备份手机数据，会额外存储一份到移动硬盘一样。我们可以给每个分片数据进行备份，存储到其它节点，防止数据丢失，这就是数据备份，也叫数据副本（replica）。

数据备份可以保证高可用，但是每个分片备份一份，所需要的节点数量就会翻一倍，成本实在是太高了！

为了在高可用和成本间寻求平衡，我们可以这样做：

首先对数据分片，存储到不同节点
然后对每个分片进行备份，放到对方节点，完成互相备份

这样可以大大减少所需要的服务节点数量，如图，我们以3分片，每个分片备份一份为例：

现在，每个分片都有1个备份，存储在3个节点：

node0：保存了分片0和1
node1：保存了分片0和2
node2：保存了分片1和2

2.4.Windows搭建集群

进入ElasticSearch的bin目录：

然后打开3个控制台，分别输入下面的3个指令：

# node0指令：
elasticsearch.bat -E node.name=node0 -E cluster.name=elastic -E path.data=node0_data
# node1指令：
elasticsearch.bat -E node.name=node1 -E cluster.name=elastic -E path.data=node1_data
# node2指令：
elasticsearch.bat -E node.name=node2 -E cluster.name=elastic -E path.data=node2_data

命令解释：

elasticsearch.bat：运行elasticsearch.bat文件
-E node.name：-E是环境参数，node.name是指定节点名称
cluster.name：指定集群名称
path.data：指定数据目录地址，相对路径是相对于ElasticSearch的安装目录

2.5.配置Kibana访问集群

2.5.1.修改配置

在Kibana中的config中打开kibana.yml文件：

找到这样一行代码：

1	# elasticsearch.hosts: ["http://localhost:9200"]

前面的#是注释，需要删除以打开注释。然后在后面的数组中添加ES的集群地址：

1	elasticsearch.hosts: ["http://localhost:9200","http://localhost:9201","http://localhost:9202"]

2.5.2.重启并访问

重启kibana，然后再左侧的菜单点击monitor：

在页面中点击按钮，打开监控功能，可能需要等待几秒钟。

然后可以看到kibana提供的监控功能：

可以看到启动的3个节点的信息：

2.6.测试集群

2.6.1.配置分片和副本信息

还记得创建索引库的API吗？

请求方式：PUT
请求路径：/索引库名
请求参数：json格式：
1
2
3
4
5
{
"settings": {
"属性名": "属性值"
}
}
settings：就是索引库设置，其中可以定义索引库的各种属性，之前我们没有配置，是默认值。

settings中就可以配置索引库的分片和副本信息，语法如下：

PUT /heima
{
  "settings": {
    "number_of_shards": 3, # 设置分片数为3
    "number_of_replicas": 1 # 设置副本数为1
  }
}

这里有两个配置：

number_of_shards：分片数量，这里设置为3
number_of_replicas：副本数量，这里设置为1，每个分片一个备份，一个原始数据，共2份。

2.6.2.查看分片结果

进入monitor页面，然后选择查看索引库（indices)信息：

可以看到我们刚刚加入的索引库：

点击进入，然后拉到页面最底部：

可以看到每个分片在节点上的信息：

node0：保存了分片0和1
node1：保存了分片0和2
node2：保存了分片1和2

这个结果与我们上面画图分析是一致的。

2.6.3.集群动态伸缩

现在，我们让node1宕机，停止node1的控制台进程即可。

然后查看Kibana中的节点状态：

发现node1已经宕机了，此时数据是不安全的。

稍等片刻，再次查看：

发现分片数据进行了重新分配，node1上的分片被重新分配了。此时集群依然是健康的。

我们重新启动node1看看：

分片再次重新分配，那么每个节点都存储了部分分片。

3.ES的Java客户端

在elasticsearch官网中提供了各种语言的客户端：https://www.elastic.co/guide/en/elasticsearch/client/index.html

而Java的客户端就有两个：

不过Java API这个客户端（Transport Client）已经在7.0以后过期了，而且在8.0版本中将直接废弃。所以我们会学习Java REST Client：

然后再选择High Level REST Client这个。

Java REST Client 其实就是利用Java语言向 ES服务发 Http的请求，因此请求和操作与前面学习的REST API 一模一样。

不过，为了后面学习，我们需要准备一些数据，导入到ES中

3.1.准备数据库数据

我们需要从数据库导入数据到ES中，因此需要做一些准备：

引入依赖
执行sql，准备数据
引入实体类
引入mybatis相关配置
引入mapper和service代码

3.1.1.创建maven项目es-demo,并引入依赖

在项目的pom文件中引入一些依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.itcast.demo</groupId>
    <artifactId>es-demo</artifactId>
    <version>1.0.0-SNAPSHOT</version>

    <dependencies>
        <!-- Junit单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <!--elastic客户端-->
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.4.2</version>
        </dependency>
        <!--数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
        </dependency>
        <!--JSON工具-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.49</version>
        </dependency>
        <!--common工具-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.8.1</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

3.1.2.执行sql

我们导入课前资料提供的Sql：tb_user.sql。或者执行sql语句：

表结构：

-- ----------------------------
-- Table structure for tb_user
-- ----------------------------
DROP TABLE IF EXISTS `tb_user`;
CREATE TABLE `tb_user`  (
  `id` bigint(20) UNSIGNED NOT NULL AUTO_INCREMENT,
  `name` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL DEFAULT '' COMMENT '姓名',
  `age` int(10) UNSIGNED NOT NULL DEFAULT 0 COMMENT '年龄',
  `gender` varchar(2) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL DEFAULT '男' COMMENT '性别',
  `note` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '' COMMENT '备注',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 13 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Records of tb_user
-- ----------------------------
INSERT INTO `tb_user` VALUES (1, '张三', 30, '男', '张三同学在学Java');
INSERT INTO `tb_user` VALUES (2, '李四', 21, '男', '李四同学在传智学Java');
INSERT INTO `tb_user` VALUES (3, '王五', 22, '男', '王五同学在学php');
INSERT INTO `tb_user` VALUES (4, '张伟', 20, '男', '张伟同学在传智播客学Java');
INSERT INTO `tb_user` VALUES (5, '李娜', 28, '女', '李娜同学在传智播客学Java');
INSERT INTO `tb_user` VALUES (6, '李磊', 23, '男', '李磊同学在传智播客学Java');
INSERT INTO `tb_user` VALUES (7, '韩梅梅', 24, '女', '韩梅梅同学在传智播客学php');
INSERT INTO `tb_user` VALUES (8, '柳岩', 21, '女', '柳岩同学在传智播客学表演');
INSERT INTO `tb_user` VALUES (9, '刘亦菲', 18, '女', '刘亦菲同学在传智播客学唱歌');
INSERT INTO `tb_user` VALUES (10, '范冰冰', 25, '女', '范冰冰同学在传智播客学表演');
INSERT INTO `tb_user` VALUES (11, '郑爽', 23, '女', '郑爽同学在传智播客学习如何装纯');
INSERT INTO `tb_user` VALUES (12, '唐嫣', 26, '女', '唐嫣同学在传智播客学习如何耍酷');

SET FOREIGN_KEY_CHECKS = 1;

3.1.3.引入实体类

实体类：

package cn.itcast.es.pojo;


import lombok.Data;

@Data
public class User {

    private Long id;

    private String name;// 姓名

    private Integer age;// 年龄

    private String gender;// 性别

    private String note;// 备注
}

3.1.4.引入mybatis配置

课前资料中提供了配置：

把：jdbc.properties、mybatis-config.xml、UserMapper.xml复制到项目中:

3.1.5.引入mapper和Service

mapper：

package cn.itcast.es.mapper;

import cn.itcast.es.pojo.User;

import java.util.List;


public interface UserMapper {

    User findById(Long id);

    List<User> findAll();
}

service:

package cn.itcast.es.service;

import cn.itcast.es.mapper.UserMapper;
import cn.itcast.es.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;


public class UserService {
    private UserMapper userMapper;

    public UserService(){
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            userMapper = sqlSessionFactory.openSession(true).getMapper(UserMapper.class);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public User findById(Long id){
        return userMapper.findById(id);
    }

    public List<User> findAll(){
        return userMapper.findAll();
    }
}

提供了根据id查询和查询所有两个功能。

3.2.连接ElasticSearch

在官网上可以看到连接ES的教程：https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high-getting-started-initialization.html

首先需要与ES建立连接，ES提供了一个客户端RestHighLevelClient。

代码如下：

RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http"),
                        new HttpHost("localhost", 9201, "http"),
                        new HttpHost("localhost", 9202, "http")
                )
        );

ES中的所有操作都是通过RestHighLevelClient来完成的：

为了后面测试方便，我们写到一个单元测试中，并且通过@Before注解来初始化客户端连接。

public class ElasticDemo {

    private RestHighLevelClient client;

    /**
     * 建立连接
     */
    @Before
    public void init() throws IOException {
        client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("localhost", 9200, "http"),
                        new HttpHost("localhost", 9201, "http"),
                        new HttpHost("localhost", 9202, "http")
                )
        );
    }

    /**
     * 关闭客户端连接
     */
    @After
    public void close() throws IOException {
        client.close();
    }
}

4.Java实现创建库和映射

开发中，往往库和映射的操作一起完成，官网详细文档地址：https://www.elastic.co/guide/en/elasticsearch/client/java-rest/7.x/_index_apis.html

这里我们主要实现库和映射的创建。查询、删除等功能大家可参考文档自己实现。

4.1.思路分析

按照官网给出的步骤，创建索引包括下面几个步骤：

1）创建CreateIndexRequest对象，并指定索引库名称
2）指定settings配置
3）指定mapping配置
4）发起请求，得到响应

其实仔细分析，与我们在Kibana中的Rest风格API完全一致：

PUT /heima
{
  "settings": {
    "number_of_shards": 3,
    "number_of_replicas": 1
  },
  "mappings": {
    
  }
}

4.2.设计映射规则

Java代码中设置mapping，依然与REST中一致，需要JSON风格的映射规则。因此我们先在kibana中给User实体类定义好映射规则。

User包括下面的字段：

Id：主键，在ES中是唯一标示，数字，可以选择long类型
name：姓名，字符串类型，但是无需分词，使用keyword，也无需查找，index为false
age：年龄，整数，可以使用integer
gender：性别，字符串类型，但是无需分词，使用keyword
note：备注，用户详细信息，字符串类型。需要分词，使用text

映射如下：

PUT /user
{
  "settings": {
    "number_of_shards": 3,
    "number_of_replicas": 1
  },
  "mappings": {
    "properties": {
      "id": {
        "type": "long"
      },
      "name":{
        "type": "keyword"
      },
      "age":{
        "type": "integer"
      },
      "gender":{
        "type": "keyword"
      },
      "note":{
        "type": "text",
        "analyzer": "ik_max_word"
      }
    }
  }
}

4.3.代码实现

我们在上面新建的ElasticDemo类中新建单元测试，完成代码，思路就是之前分析的4步骤：

1）创建CreateIndexRequest对象，并指定索引库名称
2）指定settings配置
3）指定mapping配置
4）发起请求，得到响应

private RestHighLevelClient client;

   @Test
    public void testCreateIndex() throws IOException {
        // 1.创建CreateIndexRequest对象，并指定索引库名称
        CreateIndexRequest request = new CreateIndexRequest("user");
        // 2.指定settings配置
        request.settings(Settings.builder()
                .put("index.number_of_shards", 3)
                .put("index.number_of_replicas", 1)
        );
        // 3.指定mapping配置
        request.mapping("{\n" +
                        "    \"properties\": {\n" +
                        "      \"id\": {\n" +
                        "        \"type\": \"long\"\n" +
                        "      },\n" +
                        "      \"name\":{\n" +
                        "        \"type\": \"keyword\"\n" +
                        "      },\n" +
                        "      \"age\":{\n" +
                        "        \"type\": \"integer\"\n" +
                        "      },\n" +
                        "      \"gender\":{\n" +
                        "        \"type\": \"keyword\"\n" +
                        "      },\n" +
                        "      \"note\":{\n" +
                        "        \"type\": \"text\",\n" +
                        "        \"analyzer\": \"ik_max_word\"\n" +
                        "      }\n" +
                        "    }\n" +
                        "  }",
                XContentType.JSON);
        // 4.发起请求，得到响应
        CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);

        System.out.println("response = " + response.isAcknowledged());
    }

返回结果：

1	response = true

课堂代码

package com.itheima.es;

import org.apache.http.HttpHost;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
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.client.indices.GetIndexResponse;
import org.elasticsearch.cluster.metadata.MappingMetaData;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.xcontent.XContentType;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.util.Map;

public class EsDemo {
    private RestHighLevelClient client =null ;
    @Before
    public void init(){
        // 创建客户端对象
        client = new RestHighLevelClient(
                RestClient.builder(
                        //new HttpHost("localhost", 9200, "http"),
                        new HttpHost("192.168.190.149", 9200, "http")));
    }
    // ====================TODO:操作索引库========================
    /**
     * TODO:创建索引库
     */
    @Test
    public void testIndexCreate() throws IOException {
        // 创建添加索引库的请求信息对象  指定索引库的名称
        CreateIndexRequest createIndexRequest = new CreateIndexRequest("user");
        CreateIndexResponse createIndexResponse =
                client.indices().create(createIndexRequest,RequestOptions.DEFAULT);
        System.out.println(createIndexResponse.isAcknowledged());
    }

    /**
     TODO: 操作ES流程
        1.获取客户端对象
        2.创建请求语义对象(用于封装本次请求的行为)
        3.发送请求给ES,并接收响应结果
        4.解析响应结果
     */
    /**
     * 查看索引库
     * @throws IOException
     */
    @Test
    public void testIndexGet() throws IOException {
        GetIndexRequest request = new GetIndexRequest("car");
        GetIndexResponse response = client.indices().get(request, RequestOptions.DEFAULT);
        // 获取索引库的配置信息
        Map<String, Settings> settings = response.getSettings();
        System.out.println(settings.toString());
        // 获取索引库的映射信息
        Map<String, MappingMetaData> mappings = response.getMappings();
        MappingMetaData metaData = mappings.get("car");
        Map<String, Object> sourceAsMap = metaData.sourceAsMap();
        System.out.println(sourceAsMap.toString());
    }

    /**
     * 删除索引库
     * @throws IOException
     */
    @Test
    public void testIndexDelete() throws IOException{
        DeleteIndexRequest request = new DeleteIndexRequest("user");
        AcknowledgedResponse deleteIndexResponse =
                client.indices().delete(request, RequestOptions.DEFAULT);
        System.out.println(deleteIndexResponse.isAcknowledged());
    }

    /**
     * 创建索引库时,为索引库添加属性和设置类型映射
     * @throws IOException
     */
    @Test
    public void testIndexCreate1() throws IOException{
        // 创建描述语义的对象
        CreateIndexRequest createIndexRequest = new CreateIndexRequest("user");
        // TODO:设置索引库的属性
        //createIndexRequest.settings(Settings.builder()
        //        .put("index.number_of_shards", 3)
        //        .put("index.number_of_replicas", 1)
        //);
        // TODO:设置索引库的类型映射
        //createIndexRequest.mapping(" {\n" +
        //        "    \"properties\": {\n" +
        //        "      \"id\": {\n" +
        //        "        \"type\": \"long\"\n" +
        //        "      },\n" +
        //        "      \"name\":{\n" +
        //        "        \"type\": \"keyword\"\n" +
        //        "      },\n" +
        //        "      \"age\":{\n" +
        //        "        \"type\": \"integer\"\n" +
        //        "      },\n" +
        //        "      \"gender\":{\n" +
        //        "        \"type\": \"keyword\"\n" +
        //        "      },\n" +
        //        "      \"note\":{\n" +
        //        "        \"type\": \"text\",\n" +
        //        "        \"analyzer\": \"ik_max_word\"\n" +
        //        "      }\n" +
        //        "    }\n" +
        //        "  }",XContentType.JSON);
        createIndexRequest.source("{\n" +
                "  \"settings\": {\n" +
                "    \"number_of_shards\": 3,\n" +
                "    \"number_of_replicas\": 1\n" +
                "  },\n" +
                "  \"mappings\": {\n" +
                "    \"properties\": {\n" +
                "      \"id\": {\n" +
                "        \"type\": \"long\"\n" +
                "      },\n" +
                "      \"name\":{\n" +
                "        \"type\": \"keyword\"\n" +
                "      },\n" +
                "      \"age\":{\n" +
                "        \"type\": \"integer\"\n" +
                "      },\n" +
                "      \"gender\":{\n" +
                "        \"type\": \"keyword\"\n" +
                "      },\n" +
                "      \"note\":{\n" +
                "        \"type\": \"text\",\n" +
                "        \"analyzer\": \"ik_max_word\"\n" +
                "      }\n" +
                "    }\n" +
                "  }\n" +
                "}",XContentType.JSON);
        CreateIndexResponse createIndexResponse =
                client.indices().create(createIndexRequest,RequestOptions.DEFAULT);
        System.out.println(createIndexResponse.isAcknowledged());
    }

    @After
    public void close() throws IOException {
        if (client!=null)
        this.client.close();
    }
}

5.Java实现文档的CRUD

文档操作包括：新增文档、查询文档、修改文档、删除文档等。

官网地址：https://www.elastic.co/guide/en/elasticsearch/client/java-rest/7.x/java-rest-high-supported-apis.html

5.1.新增

官网地址：https://www.elastic.co/guide/en/elasticsearch/client/java-rest/7.x/java-rest-high-document-index.html

5.1.1.实现思路

根据官网文档，实现的步骤如下：

1）创建IndexRequest对象，并指定索引库名称
2）指定新增的数据的id
3）将新增的文档数据变成JSON格式
4）将JSON数据添加到IndexRequest中
5）发起请求，得到结果

不过，我们的文档数据需要去查询数据库，因此前面会多出一个步骤：从数据库查询文档数据

1）从数据库查询文档数据
2）创建IndexRequest对象，并指定索引库名称
3）指定新增的数据的id
4）将新增的文档数据变成JSON格式
5）将JSON数据添加到IndexRequest中
6）发起请求，得到结果

5.1.2.具体代码

需要在单元测试类中线初始化UserService对象：

1	private UserService userService = new UserService();

新增文档：

/**
     TODO: 操作ES流程
        1.获取客户端对象
        2.创建请求语义对象(用于封装本次请求的行为)
        3.发送请求给ES,并接收响应结果
        4.解析响应结果
     */
    /**
     * 添加文档数据信息
     * @throws IOException
     */
    @Test
    public void docPost1() throws IOException {
        IndexRequest request = new IndexRequest("user");
        request.id("2");
        String jsonString = "{\n" +
                "    \"age\" : 18,\n" +
                "    \"gender\" :\"女\",\n" +
                "    \"name\" : \"大幂幂\",\n" +
                "    \"note\" : \"我好美啊.\"\n" +
                "}";
        request.source(jsonString, XContentType.JSON);
        IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);
        System.out.println(indexResponse.status());
    }

    @Test
    public void docPost2() throws IOException {
        User user = service.findById(12L);
        System.out.println(user);
        IndexRequest request = new IndexRequest("user");
        // 设置添加的文档id值
        //request.id(user.getId().toString());
        request.id("1");
        // 设置文档数据信息
        String jsonString = JSON.toJSONString(user);
        System.out.println(jsonString);
        request.source(jsonString, XContentType.JSON);
        IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);
        //System.out.println(indexResponse.status());
        System.out.println(indexResponse.getResult());
    }

结果：

1	indexResponse = CREATED

5.1.3.新增的ID一致时

我们之前测试过，新增的时候如果ID存在则变成修改，我们试试，再次执行刚才的代码，可以看到结果变了：

1	indexResponse = UPDATED

5.2.查询文档

官网地址：https://www.elastic.co/guide/en/elasticsearch/client/java-rest/7.x/java-rest-high-document-get.html

5.2.1.实现思路

这里的查询是根据id查询，必须知道文档的id才可以。

根据官网文档，实现的步骤如下：

1）创建GetRequest 对象，并指定索引库名称、文档ID
2）发起请求，得到结果
3）从结果中得到source，是json字符串
4）将JSON反序列化为对象

5.2.2.具体代码

/**
     * 查询文档数据
     * @throws IOException
     */
    @Test
    public void docGet() throws IOException {
        // 获取文档对象 语义描述
        GetRequest getRequest = new GetRequest("user", "1");
        // 发送请求获取文档对象
        GetResponse getResponse = client.get(getRequest, RequestOptions.DEFAULT);
        // 获取响应结果中的数据信息
        String sourceAsString = getResponse.getSourceAsString();
        System.out.println(sourceAsString);
        // 解析响应结果字符串
        User user = JSON.parseObject(sourceAsString, User.class);
        System.out.println(user);
    }

结果如下：

1
2

{"age":26,"gender":"女","id":12,"name":"唐嫣","note":"唐嫣同学在传智播客学习如何耍酷"}
User(id=12, name=唐嫣, age=26, gender=女, note=唐嫣同学在传智播客学习如何耍酷)

5.3.修改文档

新增时，如果ID一致就会覆盖旧的数据，实现修改。不过，如果我们只修改文档中的某个字段，可以使用另外的API：https://www.elastic.co/guide/en/elasticsearch/client/java-rest/7.x/java-rest-high-document-update.html

5.3.1.思路

根据官网信息，修改时需要指定某个已经存在的文档的id、然后指定要修改的字段及新的值。

基本步骤如下：

1.创建UpdateRequest对象，指定索引库名称、文档ID
2.指定要修改的字段及属性值
3.发起请求

5.3.2.代码实现

@Test
    public void docUpdate() throws IOException {
        UpdateRequest request = new UpdateRequest("user","1");
        // 设置需要修改的字段信息
        request.doc("name","唐嫣");
        UpdateResponse updateResponse =
                client.update(request, RequestOptions.DEFAULT);
        System.out.println(updateResponse.getResult());
    }

结果如下：

1	updateResponse = UPDATED

如果再次查询，可以发现李磊已经成功变性了：

1	user = User(id=6, name=李磊, age=23, gender=女, note=李磊同学在传智播客学Java)

5.4.删除文档

官网地址：https://www.elastic.co/guide/en/elasticsearch/client/java-rest/7.x/java-rest-high-document-delete.html

实现思路非常简单，直接根据ID删除即可：

1.创建DeleteRequest对象，指定索引库名称、文档ID
2.发起请求

代码实现：

@Test
public void docDelete() throws IOException {
    DeleteRequest request = new DeleteRequest("user", "1");
    DeleteResponse deleteResponse = client.delete(request, RequestOptions.DEFAULT);
    System.out.println(deleteResponse.getResult());
}

结果：

1	deleteResponse = DELETED

5.5.批处理

如果我们需要把数据库中的所有用户信息都导入索引库，可以批量查询出多个用户，但是刚刚的新增文档是一次新增一个文档，这样效率太低了。

因此ElasticSearch提供了批处理的方案：BulkRequest

https://www.elastic.co/guide/en/elasticsearch/client/java-rest/7.x/java-rest-high-document-bulk.html

5.5.1.思路分析

A BulkRequest can be used to execute multiple index, update and/or delete operations using a single request.

一个BulkRequest可以在一次请求中执行多个新增、更新、删除请求。

所以，BulkRequest就是把多个其它增、删、改请求整合，然后一起发送到ES来执行。

我们拿批量新增来举例，步骤如下：

1.从数据库查询文档数据
2.创建BulkRequest对象
3.创建多个IndexRequest对象，组织文档数据，并添加到BulkRequest中
4.发起请求

5.5.2.具体代码

/**
     * 批量添加
     * @throws IOException
     */
    @Test
    public void docBulk() throws IOException {
        // 查询mysql中的数据信息
        List<User> userList = service.findAll();
        BulkRequest request = new BulkRequest("user");

        for (User user : userList) {
            IndexRequest indexRequest = new IndexRequest();
            indexRequest.id(user.getId().toString());
            String userJson = JSON.toJSONString(user);
            indexRequest.source(userJson,XContentType.JSON);

            request.add(indexRequest);
        }

        BulkResponse bulkResponse = client.bulk(request, RequestOptions.DEFAULT);
        System.out.println(bulkResponse.status());
    }

结果如下：

1	status: OK

可以再Kibana中看到查询的结果：

6.Java实现查询

查询、搜索相关功能主要包括：

基本查询
- 分词查询
- 词条查询
- 范围查询
- 布尔查询
- Filter功能
排序
分页
高亮
source过滤

官方文档：https://www.elastic.co/guide/en/elasticsearch/client/java-rest/7.x/java-rest-high-search.html

6.1.查询的核心API

先来看下REST风格中查询的语法：

整个请求对象是一个大JSON对象，包含5部分属性：

query：查询属性
sort：排序属性
from和size：分页属性
highlight：高亮属性
aggs：聚合属性

而Java客户端，其实也是在构建这样的JSON对象。

6.1.1.SearchSourceBuilder

在Java客户端中，SearchSourceBuilder就是用来构建上面提到的大JSON对象，其中包含了5个方法：

query(QueryBuilder)：查询条件
sort(String, SortOrder)：排序条件
from(int)和size(int)：分页条件
highlight(HighlightBuilder)：高亮条件
aggregation(AggregationBuilder)：聚合条件

如图：

是不是与REST风格API的JSON对象一致？

接下来，再逐个来看每一个查询子属性。

6.1.2.查询条件QueryBuilders

SearchSourceBuilder的query(QueryBuilder)方法，用来构建查询条件，而查询分为：

分词查询：MatchQuery
词条查询：TermQuery
布尔查询：BooleanQuery
范围查询：RangeQuery
模糊查询：FuzzyQuery
…

这些查询有一个统一的工具类来提供：QueryBuilders

6.2.搜索结果API

在Kibana中看一下搜索结果：

搜索得到的结果整体是一个JSON对象，包含下列2个属性：

hits：查询结果，其中又包含两个属性：
- total：总命中数量
- hits：查询到的文档数据，是一个数组，数组中的每个对象就包含一个文档结果，又包含：
  - _source：文档原始信息
  - highlight：高亮结果信息
aggregations：聚合结果对象，其中包含多个属性，属性名称由添加聚合时的名称来确定：
- gender_agg：这个是我们创建聚合时用的聚合名称，其中包含聚合结果
  - buckets：聚合结果数组

Java客户端中的SearchResponse代表整个JSON结果

6.2.1.SearchResponse

Java客户端中的SearchResponse代表整个JSON结果，包含下面的方法：

包含两个方法：

getHits()：返回的是SearchHits，代表查询结果
getAggregations()：返回的是Aggregations，代表聚合结果

6.2.2.SearchHits查询结果

SearchHits代表查询结果的JSON对象：

包含下面的方法：

核心方法有3个：

getHits()：返回SearchHit数组
getMaxScore()：返回float，文档的最大得分
getTotalHists()：返回TotalHists，总命中数

6.2.3.SearchHit结果对象

SearchHit封装的就是结果数组中的每一个JSON对象：

包含这样的方法：

getSourceAsString()：返回的是_source
getHighLightFields()：返回是高亮结果

6.3.基本查询

6.3.1.思路分析

步骤如下：

1.创建SearchSourceBuilder对象
- 1.1.添加查询条件QueryBuilders
- 1.2.添加排序、分页等其它条件
2.创建SearchRequest对象，并制定索引库名称
3.添加SearchSourceBuilder对象到SearchRequest对象中
4.发起请求，得到结果
5.解析结果
- 5.1.获取总条数
- 5.2.获取SearchHits数组，并遍历
  - 获取其中的_source，是JSON数据
  - 把_source反序列化为User对象

6.3.2.查询所有

QueryBuilders可以实现各种查询，比如查询所有：match_all

代码如下：

@Test
public void testBasicSearch() throws IOException {
    // 1.创建SearchSourceBuilder对象
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    //  1.1.添加查询条件QueryBuilders，这里选择match_all，查询所有
    sourceBuilder.query(QueryBuilders.matchAllQuery());
    //  1.2.添加排序、分页等其它条件

    // 2.创建SearchRequest对象，并制定索引库名称
    SearchRequest request = new SearchRequest("user");
    // 3.添加SearchSourceBuilder对象到SearchRequest对象中
    request.source(sourceBuilder);
    // 4.发起请求，得到结果
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 5.解析结果
    SearchHits searchHits = response.getHits();
    //  5.1.获取总条数
    long total = searchHits.getTotalHits().value;
    System.out.println("total = " + total);
    //  5.2.获取SearchHits数组，并遍历
    SearchHit[] hits = searchHits.getHits();
    for (SearchHit hit : hits) {
        //  - 获取其中的`_source`，是JSON数据
        String json = hit.getSourceAsString();
        //  - 把`_source`反序列化为User对象
        User user = JSON.parseObject(json, User.class);
        System.out.println("user = " + user);
    }
}

结果如下：

total = 12
user = User(id=5, name=李娜, age=28, gender=女, note=李娜同学在传智播客学Java)
user = User(id=7, name=韩梅梅, age=24, gender=女, note=韩梅梅同学在传智播客学php)
user = User(id=2, name=李四, age=21, gender=男, note=李四同学在传智学Java)
user = User(id=3, name=王五, age=22, gender=男, note=王五同学在学php)
user = User(id=4, name=张伟, age=20, gender=男, note=张伟同学在传智播客学Java)
user = User(id=10, name=范冰冰, age=25, gender=女, note=范冰冰同学在传智播客学表演)
user = User(id=12, name=唐嫣, age=26, gender=女, note=唐嫣同学在传智播客学习如何耍酷)
user = User(id=1, name=张三, age=30, gender=男, note=张三同学在学Java)
user = User(id=6, name=李磊, age=23, gender=男, note=李磊同学在传智播客学Java)
user = User(id=8, name=柳岩, age=21, gender=女, note=柳岩同学在传智播客学表演)

6.3.3.分词查询

MatchQuery就是分词查询，会对搜索的内容分词后查询：

1	sourceBuilder.query(QueryBuilders.matchQuery("note", "唱歌表演"));

完整代码如下：

@Test
public void testBasicSearch() throws IOException {
    // 1.创建SearchSourceBuilder对象
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    //  1.1.添加查询条件QueryBuilders，这里选择match_all，查询所有
    //        sourceBuilder.query(QueryBuilders.matchAllQuery());
    sourceBuilder.query(QueryBuilders.matchQuery("note", "唱歌表演"));
    //  1.2.添加排序、分页等其它条件

    // 2.创建SearchRequest对象，并制定索引库名称
    SearchRequest request = new SearchRequest("user");
    // 3.添加SearchSourceBuilder对象到SearchRequest对象中
    request.source(sourceBuilder);
    // 4.发起请求，得到结果
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 5.解析结果
    SearchHits searchHits = response.getHits();
    //  5.1.获取总条数
    long total = searchHits.getTotalHits().value;
    System.out.println("total = " + total);
    //  5.2.获取SearchHits数组，并遍历
    SearchHit[] hits = searchHits.getHits();
    for (SearchHit hit : hits) {
        //  - 获取其中的`_source`，是JSON数据
        String json = hit.getSourceAsString();
        //  - 把`_source`反序列化为User对象
        User user = JSON.parseObject(json, User.class);
        System.out.println("user = " + user);
    }
}

结果：

total = 3
user = User(id=8, name=柳岩, age=21, gender=女, note=柳岩同学在传智播客学表演)
user = User(id=10, name=范冰冰, age=25, gender=女, note=范冰冰同学在传智播客学表演)
user = User(id=9, name=刘亦菲, age=18, gender=女, note=刘亦菲同学在传智播客学唱歌)

6.3.4.布尔查询

BooleanQuery就是布尔查询，需要把其它几个查询用must、must_not组合，另外过滤条件最好使用filter来实现。比如：

// 布尔查询
BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
// 添加must条件
queryBuilder.must(QueryBuilders.matchQuery("note", "唱歌表演"));
// 添加filter条件，不参与打分
queryBuilder.filter(QueryBuilders.rangeQuery("age").gte(18).lte(24));
sourceBuilder.query(queryBuilder);

完整代码：

/**
    * bool : 布尔查询
    * SearchSourceBuilder: 构建具体的查询条件
    *      - query(QueryBuilder)：查询条件
    *      - sort(String, SortOrder)：排序条件
    *      - from(int)和size(int)：分页条件
    *      - highlight(HighlightBuilder)：高亮条件
    *      - aggregation(AggregationBuilder)：聚合条件
    */
   @Test
   public void search4() throws IOException {
       // TODO:构建最终查询语义对象
       SearchRequest searchRequest = new SearchRequest("user");
       // =====构建bool查询的具体语义
       // 构建检索语义
       SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
       // 布尔检索
       BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
       // 添加must条件
       //queryBuilder.must(QueryBuilders.matchQuery("note", "唱歌表演"));
       queryBuilder.must(QueryBuilders.matchQuery("gender", "女"));
       // 添加filter条件，不影响分值
       queryBuilder.filter(QueryBuilders.rangeQuery("age").gte(18).lte(24));
       sourceBuilder.query(queryBuilder);
       //=======
       searchRequest.source(sourceBuilder);

       SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
       // 获取所有的返回结果
       SearchHits hits = searchResponse.getHits();
       TotalHits totalHits = hits.getTotalHits();
       long total = totalHits.value;
       System.out.println("总条数 : "+total);

       SearchHit[] dataHits = hits.getHits();
       for (SearchHit data : dataHits) {
           User user = JSON.parseObject(data.getSourceAsString(),User.class);
           System.out.println(user);
       }

   }

结果：

1
2
3

total = 2
user = User(id=8, name=柳岩, age=21, gender=女, note=柳岩同学在传智播客学表演)
user = User(id=9, name=刘亦菲, age=18, gender=女, note=刘亦菲同学在传智播客学唱歌)

6.4.source过滤

在原来搜索的基础上，通过SearchSourceBuilder的fetchSource(String[] includes, String[] excludes)方法实现：

includes：包含的字段
excludes：要排除的字段

代码：

1 2	// 2.source过滤，指定includes，只要id、name、note sourceBuilder.fetchSource(new String[]{"id", "name", "note"}, new String[0]);

完整代码：

@Test
public void testBasicSearch() throws IOException {
    // 1.创建SearchSourceBuilder对象
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    //  1.1.添加查询条件QueryBuilders，这里选择match_all，查询所有
    sourceBuilder.query(QueryBuilders.matchQuery("note", "唱歌表演"));

    // 2.source过滤，指定includes，只要id、name、note
    sourceBuilder.fetchSource(new String[]{"id", "name", "note"}, new String[0]);

    // 3.创建SearchRequest对象，并制定索引库名称
    SearchRequest request = new SearchRequest("user");
    // 4.添加SearchSourceBuilder对象到SearchRequest对象中
    request.source(sourceBuilder);
    // 5.发起请求，得到结果
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 6.解析结果
    SearchHits searchHits = response.getHits();
    //  6.1.获取总条数
    long total = searchHits.getTotalHits().value;
    System.out.println("total = " + total);
    //  6.2.获取SearchHits数组，并遍历
    SearchHit[] hits = searchHits.getHits();
    for (SearchHit hit : hits) {
        //  - 获取其中的`_source`，是JSON数据
        String json = hit.getSourceAsString();
        //  - 把`_source`反序列化为User对象
        User user = JSON.parseObject(json, User.class);
        System.out.println("user = " + user);
    }
}

结果：

total = 3
user = User(id=8, name=柳岩, age=null, gender=null, note=柳岩同学在传智播客学表演)
user = User(id=10, name=范冰冰, age=null, gender=null, note=范冰冰同学在传智播客学表演)
user = User(id=9, name=刘亦菲, age=null, gender=null, note=刘亦菲同学在传智播客学唱歌)

6.5.排序

6.5.1.API介绍

通过SearchSourceBuilder的sort(String, SortOrder)方法用来实现排序条件的封装：

/**
  * Adds a sort against the given field name and the sort ordering.
  *
  * @param name The name of the field，排序字段名称
  * @param order The sort ordering，排序的方式
  */
public SearchSourceBuilder sort(String name, SortOrder order) {
    // ...
}

其中的SortOrder是一个枚举，包含ASC和DESC两个枚举项：

public enum SortOrder implements Writeable {
    /**
     * Ascending order.
     */
    ASC {
		// ..
    },
    /**
     * Descending order.
     */
    DESC {
		// ..
    };
    // ...
}

6.5.2.具体实现

在原由查询的基础上，给SearchSourceBuilder中添加sort即可:

1 2	// 1.2.添加排序条件 sourceBuilder.sort("id", SortOrder.ASC);

完整代码如下：

/**
     * order
     * SearchSourceBuilder: 构建具体的查询条件
     *      - query(QueryBuilder)：查询条件
     *      - sort(String, SortOrder)：排序条件
     *      - from(int)和size(int)：分页条件
     *      - highlight(HighlightBuilder)：高亮条件
     *      - aggregation(AggregationBuilder)：聚合条件
     */
    @Test
    public void searchOrder() throws IOException {
        // 描述查询的语义
        SearchRequest searchRequest = new SearchRequest("user");
        // 构建查询条件 五大类
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());
        // 排序
        //searchSourceBuilder.sort(new ScoreSortBuilder().order(SortOrder.DESC));
        searchSourceBuilder.sort(new FieldSortBuilder("id").order(SortOrder.DESC));

        // 将查询条件对象赋给查询语义对象
        searchRequest.source(searchSourceBuilder);

        SearchResponse searchResponse =
                client.search(searchRequest, RequestOptions.DEFAULT);

        // 获取所有的返回结果
        SearchHits hits = searchResponse.getHits();
        TotalHits totalHits = hits.getTotalHits();
        long total = totalHits.value;
        System.out.println("总条数 : "+total);

        SearchHit[] dataHits = hits.getHits();
        for (SearchHit data : dataHits) {
            User user = JSON.parseObject(data.getSourceAsString(),User.class);
            System.out.println(user);
        }

    }

查询结果：

total = 12
user = User(id=1, name=张三, age=30, gender=男, note=张三同学在学Java)
user = User(id=2, name=李四, age=21, gender=男, note=李四同学在传智学Java)
user = User(id=3, name=王五, age=22, gender=男, note=王五同学在学php)
user = User(id=4, name=张伟, age=20, gender=男, note=张伟同学在传智播客学Java)
user = User(id=5, name=李娜, age=28, gender=女, note=李娜同学在传智播客学Java)
user = User(id=6, name=李磊, age=23, gender=男, note=李磊同学在传智播客学Java)
user = User(id=7, name=韩梅梅, age=24, gender=女, note=韩梅梅同学在传智播客学php)
user = User(id=8, name=柳岩, age=21, gender=女, note=柳岩同学在传智播客学表演)
user = User(id=9, name=刘亦菲, age=18, gender=女, note=刘亦菲同学在传智播客学唱歌)
user = User(id=10, name=范冰冰, age=25, gender=女, note=范冰冰同学在传智播客学表演)

6.5.分页

在原由查询的基础上，给SearchSourceBuilder中添加from和size即可。例如我们的分页信息是：

page = 1，size = 5，代表查询第一页，每页5条，可以计算出： from = (page - 1) * size = 0

所以，代码如下：

// 1.3.添加分页条件
int page = 1, size = 5;
int from = (page - 1) * size;
sourceBuilder.from(from);
sourceBuilder.size(size);

完整代码：

/**
     * 分页
     * SearchSourceBuilder: 构建具体的查询条件
     *      - query(QueryBuilder)：查询条件
     *      - sort(String, SortOrder)：排序条件
     *      - from(int)和size(int)：分页条件
     *      - highlight(HighlightBuilder)：高亮条件
     *      - aggregation(AggregationBuilder)：聚合条件
     */
    @Test
    public void searchPage() throws IOException {
        // 描述查询的语义
        SearchRequest searchRequest = new SearchRequest("user");
        // 构建查询条件 五大类
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());
        // 排序
        searchSourceBuilder.sort(new FieldSortBuilder("id").order(SortOrder.DESC));

        // 起始索引
        searchSourceBuilder.from(0);
        searchSourceBuilder.size(4);
        // 将查询条件对象赋给查询语义对象
        searchRequest.source(searchSourceBuilder);

        SearchResponse searchResponse =
                client.search(searchRequest, RequestOptions.DEFAULT);

        // 获取所有的返回结果
        SearchHits hits = searchResponse.getHits();
        TotalHits totalHits = hits.getTotalHits();
        long total = totalHits.value;
        System.out.println("总条数 : "+total);

        SearchHit[] dataHits = hits.getHits();
        for (SearchHit data : dataHits) {
            User user = JSON.parseObject(data.getSourceAsString(),User.class);
            System.out.println(user);
        }

    }

结果如下：

total = 12
user = User(id=1, name=张三, age=30, gender=男, note=张三同学在学Java)
user = User(id=2, name=李四, age=21, gender=男, note=李四同学在传智学Java)
user = User(id=3, name=王五, age=22, gender=男, note=王五同学在学php)
user = User(id=4, name=张伟, age=20, gender=男, note=张伟同学在传智播客学Java)
user = User(id=5, name=李娜, age=28, gender=女, note=李娜同学在传智播客学Java)

6.6.高亮

6.6.1.开启高亮

高亮需要在SearchSourceBuilder的highlighter()方法来实现：

1 2	// 2.高亮，指定高亮字段 sourceBuilder.highlighter(new HighlightBuilder().field("note"));

完整代码:

@Test
public void testHighlight() throws IOException {
    // 1.创建SearchSourceBuilder对象
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    //  1.1.添加查询条件QueryBuilders
    sourceBuilder.query(QueryBuilders.matchQuery("note", "唱歌表演"));

    // 2.高亮，指定高亮字段
    sourceBuilder.highlighter(new HighlightBuilder().field("note"));

    // 3.创建SearchRequest对象，并制定索引库名称
    SearchRequest request = new SearchRequest("user");
    // 4.添加SearchSourceBuilder对象到SearchRequest对象中
    request.source(sourceBuilder);
    // 5.发起请求，得到结果
    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    // 6.解析结果
    SearchHits searchHits = response.getHits();
    //  6.1.获取总条数
    long total = searchHits.getTotalHits().value;
    System.out.println("total = " + total);
    //  6.2.获取SearchHits数组，并遍历
    SearchHit[] hits = searchHits.getHits();
    for (SearchHit hit : hits) {
        //  - 获取其中的`_source`，是JSON数据
        String json = hit.getSourceAsString();
        //  - 把`_source`反序列化为User对象
        User user = JSON.parseObject(json, User.class);
        System.out.println("user = " + user);
    }
}

运行，查看结果：

total = 3
user = User(id=8, name=柳岩, age=21, gender=女, note=柳岩同学在传智播客学表演)
user = User(id=10, name=范冰冰, age=25, gender=女, note=范冰冰同学在传智播客学表演)
user = User(id=9, name=刘亦菲, age=18, gender=女, note=刘亦菲同学在传智播客学唱歌)

结果并未高亮，为什么？

这是因为查询结果中，文档数据和高亮数据是分离的：

我们需要自己在搜索结果中解析高亮结果

6.6.2.解析高亮结果

搜索结果SearchHit对象中，包含两个方法：

getSourceAsString()：返回的是_source
getHighLightFields()：返回是高亮结果，Map<String, HighlightField>，map的key是高亮字段名称

解析SearchHit并高亮的代码如下：

/**
     * 高亮
     * SearchSourceBuilder: 构建具体的查询条件
     *      - query(QueryBuilder)：查询条件
     *      - sort(String, SortOrder)：排序条件
     *      - from(int)和size(int)：分页条件
     *      - highlight(HighlightBuilder)：高亮条件
     *      - aggregation(AggregationBuilder)：聚合条件
     */
    @Test
    public void searchHighlight() throws IOException {
        // 描述查询的语义
        SearchRequest searchRequest = new SearchRequest("user");
        // 构建查询条件 五大类
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.matchQuery("note","唱歌跳舞"));
        // 高亮
        searchSourceBuilder.highlighter(new HighlightBuilder().field("note"));

        // 将查询条件对象赋给查询语义对象
        searchRequest.source(searchSourceBuilder);

        SearchResponse searchResponse =
                client.search(searchRequest, RequestOptions.DEFAULT);

        // 获取所有的返回结果
        SearchHits hits = searchResponse.getHits();
        TotalHits totalHits = hits.getTotalHits();
        long total = totalHits.value;
        System.out.println("总条数 : "+total);

        SearchHit[] dataHits = hits.getHits();
        for (SearchHit data : dataHits) {
            User user = JSON.parseObject(data.getSourceAsString(),User.class);

            // TODO:获取高亮结果
            Map<String, HighlightField> highlightFields = data.getHighlightFields();
            // 根据字段名，获取字段值
            HighlightField highlightField = highlightFields.get("note");
            // 获取高亮结果的片段数组
            Text[] fragments = highlightField.getFragments();
            // 拼接成字符串
            String note = StringUtils.join(fragments);
            System.out.println(note);
            // 覆盖旧值
            user.setNote(note);

            System.out.println(user);
        }

    }

运行结果：

total = 3
user = User(id=8, name=柳岩, age=21, gender=女, note=柳岩同学在传智播客学<em>表演</em>)
user = User(id=10, name=范冰冰, age=25, gender=女, note=范冰冰同学在传智播客学<em>表演</em>)
user = User(id=9, name=刘亦菲, age=18, gender=女, note=刘亦菲同学在传智播客学<em>唱歌</em>)

7.Java实现聚合

聚合功能通过SearchSourceBuilder的aggregation(AggregationBuilder aggregation)方法用来构建聚合条件：

/**
  * Add an aggregation to perform as part of the search.
  */
 public SearchSourceBuilder aggregation(AggregationBuilder aggregation) {
     // ..
 }

其中要用到的各种聚合如：

Term聚合
Rang聚合
Sum聚合

等都通过AggregationBuilders来提供：

7.1.添加聚合条件

举例，假如对性别字段gender做聚合，代码如下：

1	sourceBuilder.aggregation(AggregationBuilders.terms("gender_agg").field("gender"));

terms(String)：确定聚合类型是Term类型
term(“gender_agg”)：给聚合起个名字，要唯一，获取聚合结果以名称获取。
field(“gender”)：确定要聚合的字段名称，这里是gender

完整请求：

/**
    * 聚合
    * @throws IOException
    */
   @Test
   public void searchAggs() throws IOException {
       // 描述查询的语义
       SearchRequest searchRequest = new SearchRequest("user");
       // 构建查询条件 五大类
       SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
       searchSourceBuilder.query(QueryBuilders.matchAllQuery());
       // 聚合分桶
       searchSourceBuilder.aggregation(AggregationBuilders.terms("gender_agg").field("gender"));
       // 将查询条件对象赋给查询语义对象
       searchRequest.source(searchSourceBuilder);
       SearchResponse searchResponse =
               client.search(searchRequest, RequestOptions.DEFAULT);

       // 获取所有的返回结果
       SearchHits hits = searchResponse.getHits();
       TotalHits totalHits = hits.getTotalHits();
       long total = totalHits.value;
       System.out.println("总条数 : "+total);

       SearchHit[] dataHits = hits.getHits();
       for (SearchHit data : dataHits) {
           User user = JSON.parseObject(data.getSourceAsString(),User.class);
           System.out.println(user);
       }
       System.out.println("===============================");
       // 解析结果
       Aggregations aggregations = searchResponse.getAggregations();
       // 根据桶名获取数据信息
       Terms terms = aggregations.get("gender_agg");

       List<? extends Terms.Bucket> buckets = terms.getBuckets();
       for (Terms.Bucket bucket : buckets) {
           // 6.4.获取key
           String key = bucket.getKeyAsString();
           System.out.println("key = " + key);
           // 6.5.获取count
           long count = bucket.getDocCount();
           System.out.println("count = " + count);
       }

   }

7.2.解析聚合结果

聚合结果是一个JSON对象，如图：

对象的属性是聚合的名称，可以有多个。因此获取聚合要以聚合名称获取，代码如下：

// 6.解析结果
Aggregations aggregations = response.getAggregations();

// 7.根据聚合名称获取聚合结果
Aggregation aggregation = aggregations.get("gender_agg");

返回值Aggregation是一个接口，包含很多不同实现：

因为我们上面采用的是Term聚合，因此结果应该用Terms这个子接口来接收，然后就可以从中获取到Buckets数组，代码如下：

/**
    * 聚合
    * @throws IOException
    */
   @Test
   public void searchAggs() throws IOException {
       // 描述查询的语义
       SearchRequest searchRequest = new SearchRequest("user");
       // 构建查询条件 五大类
       SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
       searchSourceBuilder.query(QueryBuilders.matchAllQuery());
       // 聚合分桶
       searchSourceBuilder.aggregation(AggregationBuilders.terms("gender_agg").field("gender"));
       // 将查询条件对象赋给查询语义对象
       searchRequest.source(searchSourceBuilder);
       SearchResponse searchResponse =
               client.search(searchRequest, RequestOptions.DEFAULT);

       // 获取所有的返回结果
       SearchHits hits = searchResponse.getHits();
       TotalHits totalHits = hits.getTotalHits();
       long total = totalHits.value;
       System.out.println("总条数 : "+total);

       SearchHit[] dataHits = hits.getHits();
       for (SearchHit data : dataHits) {
           User user = JSON.parseObject(data.getSourceAsString(),User.class);
           System.out.println(user);
       }
       System.out.println("===============================");
       // 解析结果
       Aggregations aggregations = searchResponse.getAggregations();
       // 根据桶名获取数据信息
       Terms terms = aggregations.get("gender_agg");

       List<? extends Terms.Bucket> buckets = terms.getBuckets();
       for (Terms.Bucket bucket : buckets) {
           // 6.4.获取key
           String key = bucket.getKeyAsString();
           System.out.println("key = " + key);
           // 6.5.获取count
           long count = bucket.getDocCount();
           System.out.println("count = " + count);
       }

   }

打印结果：

key = 女
count = 7
key = 男
count = 5

总结

排序: 对查询结果进行排序(默认情况下根据分值排序)
    GET /{索引库名称}/_search
    {
      "query": { ... },
      "sort": [
        {
          "{排序字段}": {
            "order": "{asc或desc}"
          }
        }
      ]
    }
高亮: 给搜索的词条添加一个标记,通过给指定的标记添加样式,实现高亮效果
		GET /heima/_search
    {
      "query": {
        "match": {
          "title": "手机"
        }
      },
      "highlight": {
        "pre_tags": "<em>",
        "post_tags": "</em>", 
        "fields": {
          "title": {}
        }
      }
    }
分页: 将查询结果进行逻辑分页(查询到了所有满足条件的数据,只是展示一部分)
  	GET /heima/_search
    {
      "query": {
        "match_all": {}
      },
      "sort": [
        {
          "price": {
            "order": "asc"
          }
        }
      ],
      "from": 0, // 起始索引
      "size": 2  // 每页显示的条数
    }
Filter过滤: 不会影响词条查询时的分值
		GET /heima/_search
    {
      "query": {
        "bool": {
          "must": {
            "match": {
              "title": "小米手机"
            }
          },
          "filter": [
              {
                "range": {
                  "price": {
                    "gt": 2000,
                    "lt": 3200
                  }
                }
              }
          ]
        }
      }
    }
_source筛选: 展示指定的查询结果字段
  	GET /heima/_search
    {
      "_source": {
        "includes":["title","price"]
      },
      "query": {
        "term": {
          "price": 2699
        }
      }
    }
聚合:
		聚合分桶: 类似于mysql中的分组
		聚合度量: 类似于mysql中的聚合函数
    GET car/_search
    {
      "size": 0,
      "aggs": {
        "colors_name": {
          "terms": {
            "field": "color"
          },
          "aggs": {
            "make_name": {
              "terms": {
                "field": "make"
              },
              "aggs": {
                "max_name": {
                  "max": {
                    "field": "price"
                  }
                }
              }
            },
            "min_name":{
              "min": {
                "field": "price"
              }
            }
          }
        }
      }
    }

ES启动后就是一个web服务,直接通过浏览器发送基于http协议Rest格式的路径即可.
Kibana: 客户端,发送请求个ES,从而实现操作ES
JavaAPI:
		在java代码中发送基于HTTP协议Rest格式的请求.
		API方法较多,使用时查询