elasticsearch基础篇：概述、操作和集成

1.概述

1.1 什么是elasticsearch

elaticsearch简称为es， es是一个开源的高扩展的分布式全文检索引擎，它能够近乎实时的存储、检索数据；自身扩展性很好，能够扩展到上百台服务器，处理PB等级的数据。es运用Java开发并运用Lucene作为其中心来完结悉数索引和查找的功用，可是它的意图是经过简略的RESTful API来躲藏Lucene的复杂性，从而让全文查找变得简略。

项目引荐：依据SpringBoot2.x、SpringCloud和SpringCloudAlibaba企业级体系架构底层结构封装，处理事务开发经常见的非功用性需求，避免重复造轮子，便利事务快速开发和企业技术栈结构一致办理。引入组件化的思维完结高内聚低耦合而且高度可装备化，做到可插拔。严格控制包依靠和一致版别办理，做到最少化依靠。注重代码标准和注释，十分适合个人学习和企业运用

Github地址：github.com/plasticene/…

Gitee地址：gitee.com/plasticene3…

微信公众号：Shepherd进阶笔记

1.2 全文检索引擎

Google、百度类的网站查找，它们都是依据网页中的要害字生成索引，咱们在查找的时候输入要害字，它们会将该要害字即索引匹配到的悉数网页返回；还有常见的项目中运用日志的查找等等。关于这些非结构化的数据文本，联系型数据库查找不是能很好的支撑。

一般传统数据库，全文检索都完结的很鸡肋，由于一般也没人用数据库存文本字段。进行全文检索需求扫描整个表，假如数据量大的话即使对SQL 的语法优化，也收效甚微。树立了索引，可是维护起来也很费事，关于 insert 和 update 操作都会从头构建索引。

为了处理结构化数据查找和非结构化数据查找功能问题，咱们就需求专业，强健，强壮的全文查找引擎。

这儿说到的全文查找引擎指的是现在广泛运用的干流查找引擎。它的工作原理是计算机索引程序经过扫描文章中的每一个词，对每一个词树立一个索引，指明该词在文章中呈现的次数和位置，当用户查询时，检索程序就依据事先树立的索引进行查找，并将查找的结果反馈给用户的检索方法。这个进程相似于经过字典中的检索字表查字的进程。

1.3 elasticsearch 和 solr

Lucene 是Apache 软件基金会Jakarta 项目组的一个子项目，供给了一个简略却强壮的运用程式接口，能够做全文索引和搜寻。在Java 开发环境里Lucene 是一个老练的免费开源东西。就其自身而言，Lucene 是当时以及最近几年最受欢迎的免费Java 信息检索程序库。但Lucene 只是一个供给全文查找功用类库的中心东西包，而真实运用它还需求一个完善的服务结构建立起来进行运用。

现在市面上盛行的查找引擎软件，干流的就两款：Elasticsearch 和Solr,这两款都是依据Lucene 建立的，能够独立布置发动的查找引擎服务软件。由于内核相同，所以两者除了服务器装置、布置、办理、集群以外，关于数据的操作 修正、增加、保存、查询等等都十分相似。在运用进程中，一般都会将Elasticsearch 和Solr 这两个软件对比，然后进行选型。这两个查找引擎都是盛行的，先进的的开源查找引擎。它们都是围绕中心底层查找库 – Lucene构建的 – 但它们又是不同的。像悉数东西相同，每个都有其长处和缺点，对比如下所示：

Google 查找趋势结果表明：

1）与 Solr 相比，Elasticsearch 具有很大的吸引力，但这并不意味着Apache Solr 现已死亡。虽然有些人可能不这么认为，但Solr 仍然是最受欢迎的查找引擎之一，具有强壮的社区和开源支撑。

2）与Solr 相比，Elasticsearch 易于装置且十分轻巧。此外，你能够在几分钟内装置并运转Elasticsearch。可是，假如Elasticsearch 办理不妥，这种易于布置和运用可能会成为一个问题。依据JSON 的装备很简略，但假如要为文件中的每个装备指定注释，那么它不适合您。总的来说，假如你的运用运用的是JSON，那么Elasticsearch 是一个更好的挑选。不然，请运用Solr，由于它的schema.xml 和solrconfig.xml 都有很好的文档记录。

3）Solr 具有更大，更老练的用户，开发者和贡献者社区。ES 虽具有的规划较小但活泼的用户社区以及不断增加的贡献者社区。Solr 贡献者和提交者来自许多不同的安排，而Elasticsearch 提交者来自单个公司。

4）Solr 更老练，但ES 增加敏捷，更稳定。

5）Solr 是一个十分有据可查的产品，具有明晰的示例和API 用例场景。 Elasticsearch 的文档安排良好，但它缺少好的示例和明晰的装备阐明。

那么怎么挑选呢？

1）由于易于运用，Elasticsearch 在新开发者中更受欢迎。一个下载和一个命令就能够发动悉数。

2） 假如除了查找文本之外还需求它来处理剖析查询，Elasticsearch 是更好的挑选

3） 假如需求分布式索引，则需求挑选Elasticsearch。关于需求良好可伸缩性和以及功能分布式环境，Elasticsearch 是更好的挑选。

4） Elasticsearch 在开源日志办理用例中占有主导地位，许多安排在Elasticsearch 中索引它们的日志以使其可查找。

5） 假如你喜欢监控和目标，那么请运用Elasticsearch，由于相关于Solr，Elasticsearch 暴露了更多的要害目标

1.4 elasticsearch的运用

1）GitHub: 2013 年头，抛弃了Solr，采纳Elasticsearch 来做PB 级的查找。“GitHub 运用Elasticsearch 查找20TB 的数据，包括13 亿文件和1300 亿行代码”。

2） 维基百科：发动以Elasticsearch 为基础的中心查找架构

3） SoundCloud：“SoundCloud 运用Elasticsearch 为1.8 亿用户供给即时而精准的音乐查找服务”。

4） 百度：现在广泛运用Elasticsearch 作为文本数据剖析，收集百度悉数服务器上的各类目标数据及用户自定义数据，经过对各种数据进行多维剖析展现，辅佐定位剖析实例异常或事务层面异常。现在覆盖百度内部20 多个事务线（包括云剖析、网盟、猜测、文库、直达号、钱包、风控等），单集群最大100 台机器，200 个ES 节点，每天导入30TB+数据。

5） 新浪：运用Elasticsearch 剖析处理32 亿条实时日志。

6） 阿里：运用Elasticsearch 构建日志收集和剖析体系。

7） Stack Overflow：处理Bug 问题的网站，全英文，编程人员交流的网站

2.elasticsearch入门

2.1 elasticsearch装置

2.1.1 本地装置

本地装置elasticsearch十分简略，只要需求去elasticsearch官网下载对应的体系软件包，然后履行bin文件下的elasticsearch履行文件即可，由于我的电脑是mac，mac软件包如下所示：

发动之后，咱们在浏览器输入http://127.0.0.1:9200

{
 "name" : "node-1",
 "cluster_name" : "es-cluster",
 "cluster_uuid" : "p12KHyIqSpeZkbojXwAh-g",
 "version" : {
  "number" : "7.15.2",
  "build_flavor" : "default",
  "build_type" : "tar",
  "build_hash" : "93d5a7f6192e8a1a12e154a2b81bf6fa7309da0c",
  "build_date" : "2021-11-04T14:04:42.515624022Z",
  "build_snapshot" : false,
  "lucene_version" : "8.9.0",
  "minimum_wire_compatibility_version" : "6.8.0",
  "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
 "tagline" : "You Know, for Search"
}

假如咱们想本地布置集群：

bin/elasticsearch -E node.name=node-1 -E cluster.name=es-cluster -E path.data=node1_data
bin/elasticsearch -E node.name=node-2 -E cluster.name=es-cluster -E path.data=node2_data
bin/elasticsearch -E node.name=node-3 -E cluster.name=es-cluster -E path.data=node3_data

这儿在发动命令后边bin/elasticsearch，需求指定集群称号，节点称号，不同节点的节点称号有必要唯一，集群称号有必要唯一，path.data指定数据存放的途径，能够不指定，这儿是由于在本地一个机器一个装置包起三个节点模拟集群，所以需求指定一下，不同节点的存放数据途径不相同。布置之后，检查集群信息，在浏览器输入http://127.0.0.1:9200/_cat/nodes?v

ip     heap.percent ram.percent cpu load_1m load_5m load_15m node.role  master name
127.0.0.1      45      98  18   2.05          cdfhilmrstw *    node-2
127.0.0.1       9      98  18   2.05          cdfhilmrstw -    node-3
127.0.0.1      16      98  18   2.05          cdfhilmrstw -    node-1

留意：9300 端口为Elasticsearch 集群间组件的通讯端口，9200 端口为浏览器拜访的http

Elasticsearch 是运用java 开发的，且7.8 版别的ES 需求JDK 版别1.8 以上，默许装置包带有jdk 环境，假如体系装备JAVA_HOME，那么运用体系默许的JDK，假如没有装备运用自带的JDK，一般主张运用体系装备的JDK，换句话说，希望在装置elasticsearch先装置装备好java jdk环境。

一起，假如咱们想要修正elasticsearch的内存大小：请修正config/jvm.options 装备文件

# 设置JVM 初始内存为1G。此值能够设置与-Xmx 相同，以避免每次废物回收完结后JVM 从头分配内存
# Xms represents the initial size of total heap space
# 设置JVM 最大可用内存为1G
# Xmx represents the maximum size of total heap space
-Xms1g
-Xmx1g

2.1.2 运用docker装置elasticsearch

运用docker装置elasticsearch十分简略，elasticsearch官方供给了镜像，咱们只需求按照如下过程装置即可：

1）拉取elasticsearch和kibana镜像，这儿拉取7.4.2的版别

# 存储和检索数据
docker pull elasticsearch:7.4.2
​

2）装备挂载数据的文件夹

# 创立装备文件目录
mkdir -p /mydata/elasticsearch/config
​
# 创立数据目录
mkdir -p /mydata/elasticsearch/data
​
# 将/mydata/elasticsearch/文件夹中文件都可读可写
chmod -R 777 /mydata/elasticsearch/
​
# 装备任意机器能够拜访 elasticsearch
echo "http.host: 0.0.0.0" >/mydata/elasticsearch/config/elasticsearch.yml

3）运转发动elasticsearch服务

docker run --name elasticsearch -p 9200:9200 -p 9300:9300 \
-e "discovery.type=single-node" \
-e ES_JAVA_OPTS="-Xms64m -Xmx512m" \
-v /mydata/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /mydata/elasticsearch/data:/usr/share/elasticsearch/data \
-v  /mydata/elasticsearch/plugins:/usr/share/elasticsearch/plugins \
-d elasticsearch:7.4.2 

• -p 9200:9200 -p 9300:9300：向外暴露两个端口，9200用于HTTP REST API恳求，9300 ES 在分布式集群状态下 ES 之间的通讯端口；
• -e "discovery.type=single-node"：es 以单节点运转
• -e ES_JAVA_OPTS="-Xms64m -Xmx512m"：设置发动占用内存，不设置可能会占用当时体系悉数内存
• -v：挂载容器中的装备文件、数据文件、插件数据到本机的文件夹；
• -d elasticsearch:7.4.2：指定要发动的镜像

4）设置elasticsearch随docker重启

# 当时 Docker 开机自启，所以 ES 现在也是开机自启
docker update elasticsearch --restart=always

2.1.3 运用k8s装置elasticsearch

由于运用k8s装置elasticsearch比较吃装备，而且已然都用k8s布置了，肯定是集群布置，有点难度，待后续研究补上…………..

2.1.4 装置ES的图形化界面插件

1）装置elasticsearch-head-master插件

这个插件直接装置在浏览器中，比如说google中，然后咱们就能够衔接elasticsearch，检查相关信息了，如下所示：

2）装置kibana

Kibana 是一个免费且开放的用户界面，能够让你对 Elasticsearch 数据进行可视化，并让你在 Elastic Stack 中进行导航。你能够进行各种操作，从跟踪查询负载，到了解恳求怎么流经你的整个运用，都能轻松完结。

本地化装置和装置elasticsearch相同去elastic公司官网下载装置软件包，履行bin下面kibana履行文件即可，可是装置之前，需求修正装备config/kibana.yml 文件：

# 默许端口
server.port: 5601
# ES 服务器的地址
elasticsearch.hosts: ["http://localhost:9200"]
# 索引名
kibana.index: ".kibana"
# 支撑中文
i18n.locale: "zh-CN"

发动之后在浏览器输入http://127.0.0.1:5601就能够看到如下：

在kibana中有一个dev-tools东西是咱们经常运用的，咱们能够在这儿输入DSL查询句子，查询es中的文档数据。

当然咱们也能够运用docker布置，十分简略。

docker run --name kibana \
-e ELASTICSEARCH_HOSTS=http://192.168.163.131:9200 \
-p 5601:5601 \
-d kibana:7.4.2

-e ELASTICSEARCH_HOSTS=``http://192.168.163.131:9200: 这儿要设置成自己的虚拟机IP地址

2.2 elasticsearch中的数据格式

Elasticsearch 是面向文档型数据库，一条数据在这儿就是一个文档。为了便利大家了解，咱们将Elasticsearch 里存储文档数据和联系型数据库MySQL 存储数据的概念进行一个类比

ES 里的Index 能够看做一个库，而Types 相当于表，Documents 则相当于表的行。这儿Types 的概念现已被逐步弱化，Elasticsearch 6.X 中，一个index 下现已只能包括一个type，Elasticsearch 7.X 中, Type 的概念现已被删除了

2.3 elasticsearch的增修正查操作

咱们对elasticsearch数据进行操作能够运用postman发送http恳求，由于elasticsearch供给了rest API支撑；也能够经过可视化插件、kibana书写DSL句子操作es数据，引荐运用后者，由于这种方法咱们平常运用Navicat操作联系型数据库数据相同。

这儿列举几个rest api操作，其实rest api和kinaba的DSL句子迥然不同：

1）新增索引

运用rest api的PUT http:127.0.0.1:9200/product 就能够创立一个名为product索引了

运用DSL句子也十分简略，运用如下句子即可：创立一个product索引，并设置索引分片数为3，分片副本数为2

PUT product
{
 "settings": {
  "number_of_shards": 3
   , "number_of_replicas": 2
  }
}

2）删除索引

DELETE product

3）_cat 检查es相关信息

#检查悉数索引   ?v 查询的信息更多
GET _cat/indices?v
​
#检查悉数节点   ?v 查询的信息更多
GET _cat/nodes?v

4）新增文档数据

咱们能够运用PUT和POST新增文档数据， POST新增，假如不指定id，会主动生成id。指定id假如该id存在就会修正这个数据，并新增版别号；PUT能够新增也能够修正。PUT有必要指定id；由于PUT需求指定id，咱们一般用来做修正操作，不指定id会报错。

POST product/_doc/1
{
 "name":"苹果手机13pro",
 "category":"手机",
 "price":6599,
 "stock":100,
 "brand":"apple",
 "desc":"苹果的手机真的很好用啊"
}
​
PUT product/_doc/2
{
 "name":"华为p50 pro",
 "category":"手机",
 "price":4999,
 "stock":38,
 "brand":"huawei",
 "desc":"摄影最佳挑选，国产手机的骄傲",
 "createTime":"2021-10-11 07:10:00"
}
​

留意这儿无论是PUT仍是POST，当id存在都是修正数据，可是他们的修正方法都是删除老文档数据，然后再刺进。假如要想依据原文档修正某个字段属性值，要运用如下：

POST product/_doc/1/_update
{
 "doc":{
  "name":"红富士苹果"
  }
}

批量刺进运用bulk

POST product/_bulk
{ "index": { "_id": 4 }}
{ "name":"小米11","category":"电子产品", "price":2999, "stock":10000 }
{ "index": { "_id": 5 }}
{ "name":"oppo findx","category":"电子产品", "price":5000, "stock":6666 }
{ "index": { "_id": 6 }}
{ "name":"vivo v20","category":"女性电子产品", "price":3999, "stock":8888 }
​

5）查询数据

#查询悉数
GET product/_search
{
 "query": {
  "match_all": {}
  }
}
​
# 匹配查询，留意match只能放一个字段条件
GET product/_search
{
 "query": {
  "match": {
   "name": "小米苹果"
   }
  }
}
​
# 匹配查询  多个条件组合
GET product/_search
{
 "query": {
  "bool": {
   "must": [
     {"match": {
     "category": "手机"
     }},
     {
     "match": {
      "name": "苹果"
      }
     }
    ]
   }
  }
}
​
# 多字段匹配查询
GET product/_search
{
 "query": {
  "multi_match": {
   "query": "苹果",
   "fields": ["name", "desc"]
   }
  }
}
​
#精确匹配term
GET product/_search
{
 "query": {
  "term": {
   "stock": {
    "value":38
    }
   }
  }
}
​
# 范围查询
GET product/_search
{
 "query": {
  "range": {
   "stock": {
    "gte": 10,
    "lte": 100
    }
   }
  }
}
​
# 排序
GET student/_search
{
 "query": {
  "match_all": {}
  },
 "sort": [
   {
   "rank": {
    "order": "desc"
    },
   "age":
    {
    "order":"desc"
    }
   
   }
  ]
}
​
# 分页查询
GET product/_search
{
 "query": {
  "match_all": {}
  },
 "sort": [
   {
   "_id": {
    "order": "desc"
    }
   }
  ], 
 "from": 0,
 "size": 2
}
​
# 索引mapping增加字段
PUT /product/_mapping
{
 "properties": {
  "title": {
   "type": "text"
   }
  }
}
 
​
# 分词器测验
GET product/_analyze
{
 "analyzer": "ik_smart",
 "text": "我是一个中国人，测验中文分词器"
}
​

更多高阶、具体查询句子请自行查询相关文档。

3.springboot集成elasticsearch

springboot集成es现在干流的方法大概有两种：集成elasticsearch rest client和运用spring data。

今日讲一下集成rest client，在pom.xml加上下面依靠即可：

   <dependency>
      <groupId>org.elasticsearch</groupId>
      <artifactId>elasticsearch</artifactId>
    </dependency>
    <!-- elasticsearch的客户端 -->
    <dependency>
      <groupId>org.elasticsearch.client</groupId>
      <artifactId>elasticsearch-rest-high-level-client</artifactId>
    </dependency>
    <!-- elasticsearch依靠2.x的log4j -->
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-api</artifactId>
    </dependency>
    <dependency>
      <groupId>org.apache.logging.log4j</groupId>
      <artifactId>log4j-core</artifactId>
    </dependency>
​
    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.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>

接下来主要讲述一下es的文档doc的增修正查，这是咱们在平常开发项目中主要用到的

1）新增文档

public class InsertDoc {
  public static void main(String[] args) throws Exception {
​
    RestHighLevelClient esClient = new RestHighLevelClient(
        RestClient.builder(new HttpHost("127.0.0.1", 9200, "http"))
     );
​
    // 刺进数据
    IndexRequest request = new IndexRequest();
    request.index("user").id("1001");
​
    User user = new User();
    user.setName("zhangsan");
    user.setAge(30);
    user.setSex("男");
​
    // 向ES刺进数据，有必要将数据转换位JSON格式
    ObjectMapper mapper = new ObjectMapper();
    String userJson = mapper.writeValueAsString(user);
​
    request.source(userJson, XContentType.JSON);
​
    IndexResponse response = esClient.index(request, RequestOptions.DEFAULT);
​
    System.out.println(response.getResult());
​
    esClient.close();
   }
}

批量新增文档

/**
 * @author fjzheng
 * @version 1.0
 * @date 2021/12/7 17:23
 */
public class InsertDocBatch {
  public static void main(String[] args) throws Exception {
​
    RestHighLevelClient esClient = new RestHighLevelClient(
        RestClient.builder(new HttpHost("127.0.0.1", 9200, "http"))
     );
​
    // 批量刺进数据
    BulkRequest request = new BulkRequest();
​
    request.add(new IndexRequest().index("user").id("1001").source(XContentType.JSON, "name", "zhangsan", "age",30,"sex","男"));
    request.add(new IndexRequest().index("user").id("1002").source(XContentType.JSON, "name", "lisi", "age",30,"sex","女"));
    request.add(new IndexRequest().index("user").id("1003").source(XContentType.JSON, "name", "wangwu", "age",40,"sex","男"));
    request.add(new IndexRequest().index("user").id("1004").source(XContentType.JSON, "name", "wangwu1", "age",40,"sex","女"));
    request.add(new IndexRequest().index("user").id("1005").source(XContentType.JSON, "name", "wangwu2", "age",50,"sex","男"));
    request.add(new IndexRequest().index("user").id("1006").source(XContentType.JSON, "name", "wangwu3", "age",50,"sex","男"));
    request.add(new IndexRequest().index("user").id("1007").source(XContentType.JSON, "name", "wangwu44", "age",60,"sex","男"));
    request.add(new IndexRequest().index("user").id("1008").source(XContentType.JSON, "name", "wangwu555", "age",60,"sex","男"));
    request.add(new IndexRequest().index("user").id("1009").source(XContentType.JSON, "name", "wangwu66666", "age",60,"sex","男"));
​
    BulkResponse response = esClient.bulk(request, RequestOptions.DEFAULT);
    System.out.println(response.getTook());
    System.out.println(response.getItems());
​
    esClient.close();
   }
}

2）更新文档

public class UpdateDoc {
  public static void main(String[] args) throws Exception {
​
    RestHighLevelClient esClient = new RestHighLevelClient(
        RestClient.builder(new HttpHost("localhost", 9200, "http"))
     );
​
    // 修正数据
    UpdateRequest request = new UpdateRequest();
    request.index("user").id("1001");
    request.doc(XContentType.JSON, "sex", "女");
​
    UpdateResponse response = esClient.update(request, RequestOptions.DEFAULT);
​
    System.out.println(response.getResult());
​
    esClient.close();
   }
}

3）删除文档

/**
 * @author fjzheng
 * @version 1.0
 * @date 2021/12/7 18:08
 */
public class DeleteDoc {
  public static void main(String[] args) throws Exception {
​
    RestHighLevelClient esClient = new RestHighLevelClient(
        RestClient.builder(new HttpHost("localhost", 9200, "http"))
     );
​
​
    DeleteRequest request = new DeleteRequest();
    request.index("user").id("1001");
​
    DeleteResponse response = esClient.delete(request, RequestOptions.DEFAULT);
    System.out.println(response.toString());
​
    esClient.close();
   }
}
​

4）依据id查询文档

public class GetDoc {
  public static void main(String[] args) throws Exception {
​
    RestHighLevelClient esClient = new RestHighLevelClient(
        RestClient.builder(new HttpHost("localhost", 9200, "http"))
     );
​
    // 查询数据
    GetRequest request = new GetRequest();
    request.index("user").id("1001");
    GetResponse response = esClient.get(request, RequestOptions.DEFAULT);
​
    System.out.println(response.getSourceAsString());
​
    esClient.close();
   }
​
}

5）多条件复杂查询

/**
 * @author fjzheng
 * @version 1.0
 * @date 2021/12/7 17:36
 */
public class SearchDoc {
  public static void main(String[] args) throws Exception {
​
    RestHighLevelClient esClient = new RestHighLevelClient(
        RestClient.builder(new HttpHost("localhost", 9200, "http"))
     );
​
    // 1. 查询索引中悉数的数据
//     SearchRequest request = new SearchRequest();
//     request.indices("user");
//
//     request.source(new SearchSourceBuilder().query(QueryBuilders.matchAllQuery()));
//
//     SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
//
//     SearchHits hits = response.getHits();
//
//     System.out.println(hits.getTotalHits());
//     System.out.println(response.getTook());
//
//     for ( SearchHit hit : hits ) {
//       System.out.println(hit.getSourceAsString());
//     }
​
    // 2. 条件查询 : termQuery
//     SearchRequest request = new SearchRequest();
//     request.indices("user");
//
//     request.source(new SearchSourceBuilder().query(QueryBuilders.termQuery("age", 30)));
//     SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
//
//     SearchHits hits = response.getHits();
//
//     System.out.println(hits.getTotalHits());
//     System.out.println(response.getTook());
//
//     for ( SearchHit hit : hits ) {
//       System.out.println(hit.getSourceAsString());
//     }
​
    // 3. 分页查询
//     SearchRequest request = new SearchRequest();
//     request.indices("user");
//
//     SearchSourceBuilder builder = new SearchSourceBuilder().query(QueryBuilders.matchAllQuery());
//     // (当时页码-1)*每页显现数据条数
//     builder.from(2);
//     builder.size(2);
//     request.source(builder);
//     SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
//
//     SearchHits hits = response.getHits();
//
//     System.out.println(hits.getTotalHits());
//     System.out.println(response.getTook());
//
//     for ( SearchHit hit : hits ) {
//       System.out.println(hit.getSourceAsString());
//     }
​
//     // 4. 查询排序
//     SearchRequest request = new SearchRequest();
//     request.indices("user");
//
//     SearchSourceBuilder builder = new SearchSourceBuilder().query(QueryBuilders.matchAllQuery());
//     //
//     builder.sort("age", SortOrder.DESC);
//
//     request.source(builder);
//     SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
//
//     SearchHits hits = response.getHits();
//
//     System.out.println(hits.getTotalHits());
//     System.out.println(response.getTook());
//
//     for ( SearchHit hit : hits ) {
//       System.out.println(hit.getSourceAsString());
//     }
​
//     // 5. 过滤字段
//     SearchRequest request = new SearchRequest();
//     request.indices("user");
//
//     SearchSourceBuilder builder = new SearchSourceBuilder().query(QueryBuilders.matchAllQuery());
//     //
//     String[] excludes = {"age"};
//     String[] includes = {};
//     builder.fetchSource(includes, excludes);
//
//     request.source(builder);
//     SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
//
//     SearchHits hits = response.getHits();
//
//     System.out.println(hits.getTotalHits());
//     System.out.println(response.getTook());
//
//     for ( SearchHit hit : hits ) {
//       System.out.println(hit.getSourceAsString());
//     }
​
//     // 6. 组合查询
//     SearchRequest request = new SearchRequest();
//     request.indices("user");
//
//     SearchSourceBuilder builder = new SearchSourceBuilder();
//     BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
//
//     //boolQueryBuilder.must(QueryBuilders.matchQuery("age", 30));
//     //boolQueryBuilder.must(QueryBuilders.matchQuery("sex", "男"));
//     //boolQueryBuilder.mustNot(QueryBuilders.matchQuery("sex", "男"));
//     boolQueryBuilder.should(QueryBuilders.matchQuery("age", 30));
//     boolQueryBuilder.should(QueryBuilders.matchQuery("age", 40));
//
//     builder.query(boolQueryBuilder);
//
//     request.source(builder);
//     SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
//
//     SearchHits hits = response.getHits();
//
//     System.out.println(hits.getTotalHits());
//     System.out.println(response.getTook());
//
//     for ( SearchHit hit : hits ) {
//       System.out.println(hit.getSourceAsString());
//     }
​
//     // 7. 范围查询
//     SearchRequest request = new SearchRequest();
//     request.indices("user");
//
//     SearchSourceBuilder builder = new SearchSourceBuilder();
//     RangeQueryBuilder rangeQuery = QueryBuilders.rangeQuery("age");
//
//     rangeQuery.gte(30);
//     rangeQuery.lt(50);
//
//     builder.query(rangeQuery);
//
//     request.source(builder);
//     SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
//
//     SearchHits hits = response.getHits();
//
//     System.out.println(hits.getTotalHits());
//     System.out.println(response.getTook());
//
//     for ( SearchHit hit : hits ) {
//       System.out.println(hit.getSourceAsString());
//     }
​
    // 8. 模糊查询
//     SearchRequest request = new SearchRequest();
//     request.indices("user");
//
//     SearchSourceBuilder builder = new SearchSourceBuilder();
//     builder.query(QueryBuilders.fuzzyQuery("name", "wangwu").fuzziness(Fuzziness.TWO));
//
//     request.source(builder);
//     SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
//
//     SearchHits hits = response.getHits();
//
//     System.out.println(hits.getTotalHits());
//     System.out.println(response.getTook());
//
//     for ( SearchHit hit : hits ) {
//       System.out.println(hit.getSourceAsString());
//     }
​
//     // 9. 高亮查询
//     SearchRequest request = new SearchRequest();
//     request.indices("user");
//
//     SearchSourceBuilder builder = new SearchSourceBuilder();
//     TermsQueryBuilder termsQueryBuilder = QueryBuilders.termsQuery("name", "zhangsan");
//
//     HighlightBuilder highlightBuilder = new HighlightBuilder();
//     highlightBuilder.preTags("<font>");
//     highlightBuilder.postTags("</font>");
//     highlightBuilder.field("name");
//
//     builder.highlighter(highlightBuilder);
//     builder.query(termsQueryBuilder);
//
//     request.source(builder);
//     SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
//
//     SearchHits hits = response.getHits();
//
//     System.out.println(hits.getTotalHits());
//     System.out.println(response.getTook());
//
//     for ( SearchHit hit : hits ) {
//       System.out.println(hit.getSourceAsString());
//     }
​
//     // 10. 聚合查询
//     SearchRequest request = new SearchRequest();
//     request.indices("user");
//
//     SearchSourceBuilder builder = new SearchSourceBuilder();
//
//     AggregationBuilder aggregationBuilder = AggregationBuilders.max("maxAge").field("age");
//     builder.aggregation(aggregationBuilder);
//
//     request.source(builder);
//     SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
//
//     SearchHits hits = response.getHits();
//
//     System.out.println(hits.getTotalHits());
//     System.out.println(response.getTook());
//
//     for ( SearchHit hit : hits ) {
//       System.out.println(hit.getSourceAsString());
//     }
​
    // 11. 分组查询
    SearchRequest request = new SearchRequest();
    request.indices("user");
​
    SearchSourceBuilder builder = new SearchSourceBuilder();
​
    AggregationBuilder aggregationBuilder = AggregationBuilders.terms("ageGroup").field("age");
    builder.aggregation(aggregationBuilder);
​
    request.source(builder);
    SearchResponse response = esClient.search(request, RequestOptions.DEFAULT);
​
    SearchHits hits = response.getHits();
​
    System.out.println(hits.getTotalHits());
    System.out.println(response.getTook());
​
    for ( SearchHit hit : hits ) {
      System.out.println(hit.getSourceAsString());
     }
​
​
​
    esClient.close();
   }
}