es学习笔记

elasticsearch

ElasticSearch: https://mirrors.huaweicloud.com/elasticsearch/?C=N&O=D

logstash: https://mirrors.huaweicloud.com/logstash/?C=N&O=D

可视化界面elasticsearch-head.https://github.com/mobz/elasticsearch-head

kibana: https://mirrors.huaweicloud.com/kibana/?C=N&O=D

ik分词器 https://github.com/medcl/elasticsearch-analysis-ik

1. Elasticsearch

ElasticSearch是一个基于RESTful web接口的开源分布式搜索引擎。它用于全文搜索、结构化搜索、分析以及将这三者混合使用。它可以近乎实施的存储、检索数据；本身扩展性很好，可以扩展到上百台服务器，处理PB级别的数据，它让你以前所未有的速度处理大数据成为可能。目的是通过简单的RESTful API来隐藏Lucene的复杂性，从而让全文搜索变得简单。

1.1 Elasticsearch 与 Solr 的比较总结

• Solr 利用 Zookeeper 进行分布式管理，而 Elasticsearch 自身带有分布式协调管理功能;

• Solr 支持更多格式的数据，而 Elasticsearch 仅支持json文件格式；

• Solr光放提供的功能更多，而ElasticSearch本身更注重于核心功能，高级功能多有第三方插件提供，例如图形化界面需要kibana友好支撑；

• Solr 查询快，但更新索引慢（插入删除慢），用于电商等查询多的应用

  • ES建立索引快（查询慢），即实时性查询快，用于facebook、新浪等搜索

  • Solr是传统搜索应用的有力解决方案，但ElasticSearch更适用于新兴的实时搜索应用

1.2 ELK

ELK是Elasticsearch、Logstash、Kibana的简称，这三者是核心套件，但并非全部。 Elasticsearch是实时全文搜索和分析引擎，提供搜集、分析、存储数据三大功能；是一套开放REST和JAVA API等结构提供高效搜索功能，可扩展的分布式系统。它构建于Apache Lucene搜索引擎库之上。 Logstash是一个用来搜集、分析、过滤日志的工具。它支持几乎任何类型的日志，包括系统日志、错误日志和自定义应用程序日志。它可以从许多来源接收日志，这些来源包括 syslog、消息传递（例如 RabbitMQ）和JMX，它能够以多种方式输出数据，包括电子邮件、websockets和Elasticsearch。 Kibana是一个基于Web的图形界面，用于搜索、分析和可视化存储在 Elasticsearch指标中的日志数据。它利用Elasticsearch的REST接口来检索数据，不仅允许用户创建他们自己的数据的定制仪表板视图，还允许他们以特殊的方式查询和过滤数据。

2. ES核心概念

Relational DB	Elasticsearch
数据库（database）	索引（indices）
表（tables）	types
行（rows）	documents
字段（columns）	fields

物理设计：

elasticsearch在后台把每个索引划分成多个分片。每个分片可以在集群中的不同服务器间迁移

逻辑设计：

一个索引类型中，包含多个文档，当我们索引一篇文档时，可以通过这样的一个顺序找到它：索引>类型>文档id，通过这个组合我们就能索引到某个具体的文档。注意：ID不必是整数，实际上它是一个字符串。

2.1 字段 Field

字段在ES中可以理解为JSON数据的键，下面的JSON数据中，name 就是一个字段。

一个document中有多个field，每个field就是一个字段。

 {
     "name"："jack"
 }

2.2 文档 Document

在ES中相当于传统数据库中的行概念，ES中的数据都以JSON的形式来表示，在MySQL中插入一行数据和ES中插入一个JSON文档是一个意思。文档，ES中最小的数据单元，一个document就是一条数据。

下面的JSON数据表示，一个包含3个字段的文档：

 {
     "name"："jack"，
     "age"：18，
     "gender"：1
 }

之前说elasticsearch是面向文档的，那么就意味着索弓和搜索数据的最小单位是文档， elasticsearch中，文档有几个重要属性：

• 自我包含， 一篇文档同时包含字段和对应的值，也就是同时包含key：value

• 可以是层次型的，一个文档中包含子文档，复杂的逻辑实体就是这么来的【就是一 个json对象!，fastjson进行自动转换】

• 灵活的结构，文档不依赖预先定义的模式，我们知道关系型数据库中，要提前定义字段才能使用，在ES中，对于字段是非常灵活的，有时候，我们可以忽略该字段或者动态的添加一个新的字段

尽管我们可以随意的新增或者忽略某个字段，但是每个字段的类型非常重要，比如一个年龄字段类型，可以是字符串也可以是整形。

2.3 类型

映射 是对文档中每个字段的类型进行定义，每一种数据类型都有对应的使用场景。例如：string的数据会被作为全文本来处理，这种数据类型适合需要搜索的场景。有些数据类型，你不需要对它进行搜索，相反需要对它做聚合运算，那么keyword、integer 数据类型就更合适。 正如上面说的，每个文档都有映射，但是在大多数使用场景中，我们并不需要显示的创建映射，因为ES中实现了动态映射。我们在索引中写入一个下面的JSON文档，在动态映射的作用下，name会映射成text类型，age会映射成long类型。

 {
     "name"："jack"，
     "age"：18，
 }

既然有动态映射，我们当然也可以自定义映射，在深度使用中，我们需要对数据类型进行精确的控制，以达到我们实际场景的要求，ES可能不知道我们需要数据类型，这种情况下我们可以使用自定义映射。通过映射API，我们可以方便的创建、修改、查看、删除映射。

2.4 索引 Index

索引是ES中最大的数据单元，相当于关系型数据库中库的概念，存放有相似结构的文档数据，一个index中包含了很多类似或者相同的document。前面我们说一个文档相当于MySQL中一行数据，如果按照关系型数据库中的对应关系，还应该有表的概念。ES中没有表的概念，这是ES和数据库的一个区别，在我们建立索引之后，可以直接往索引中写入文档。在6.0版本之前，ES中有Type的概念，可以理解成关系型数据库中的表，但是官方说这是一个设计上的失误，所以在6.0版本之Type就被废弃了。

2.5 分片 Shards

索引是ES中最大的数据存储单元，我们可以往索引中不断写入文档，到了一定数量级，索引文件就会占满整个服务器的磁盘，磁盘容量只是其中一个问题，索引文件变的大，会严重降低搜索的效率。分片就是用来解决这些问题的，简单来讲，分片就是把单索引文件分成多份存储，且这些索引的分片可以分部在不同的机器上。假设单台机器磁盘容量1TB，现在需要存放5TB的索引数据，那就可以把5TB索引分成10份，分别存放到10台机器上每份500G，这就是所谓的分片。

我们来研究下分片是如何工作的。

物理设计：节点和分片如何工作

一个集群至少有一 个节点，而一个节点就是一个elasricsearch进程 ，节点可以有多个索引默认的，如果你创建索引，那么索引将会有个5个分片( primary shard ，又称主分片)构成的，每一个主分片会有一个副本( replica shard ，又称复制分片）

上图是一个有3个节点的集群，可以看到主分片和对应的复制分片都不会在同个节点内，这样有利于某个节点挂掉了，数据也不至于丢失。实际上， 一个分片是一个Lucene索引， 一个包含倒排索引的文件目录，倒排索引的结构使得elasticsearch在不扫描全部文档的情况下，就能告诉你哪些文档包含特定的关键字。

2.5.1 倒排索引

ES使用的是一种称为倒排索引的结构，采用Lucene倒排索作为底层。这种结构适用于快速的全文搜索，一个索引由文档中所有不重复的列表构成，对于每一个词，都有一个包含它的文档列表。 例如，现在有两个文档，每个文档包含如下内容：

 Study every day， good good up to forever  # 文 档1包含的内容
 To forever， study every day，good good up  # 文档2包含的内容

为创建倒排索引，我们首先要将每个文档拆分成独立的词(或称为词条或者tokens) ，然后创建一个包含所有不重复的词条的排序列表，然后列出每个词条出现在哪个文档：

term	doc_1	doc_2
Study	√	x
To	x	x
every	√	√
forever	√	√
day	√	√
study	x	√
good	√	√
every	√	√
to	√	x
up	√	√

现在，我们试图搜索 to forever，只需要查看包含每个词条的文档

term	doc_1	doc_2
to	√	x
forever	√	√
total	2	1

两个文档都匹配，但是第一个文档比第二个匹配程度更高。如果没有别的条件，现在，这两个包含关键字的文档都将返回。 再来看一个示例，比如我们通过博客标签来搜索博客文章。那么倒排索引列表就是这样的一个结构：

博客文章(原始数据)	博客文章(原始数据)	索引列表(倒排索引)	索引列表(倒排索引)
博客文章ID	标签	标签	博客文章ID
1	python	python	1，2，3
2	python	linux	3，4
3	linux，python
4	linux

如果要搜索含有python标签的文章，那相对于查找所有原始数据而言，查找倒排索引后的数据将会快的多。只需要查看标签这一栏，然后获取相关的文章ID即可。完全过滤掉无关的所有数据，提高效率！

elasticsearch的索引和Lucene的索引对比

在ES中 ，索引被分为多个分片，每份分片是个Lucene的索引。

所以一个elasticsearch索引是由多 个Lucene索引组成的。ES使用Lucene作为底层。

2.6 副本 Replicas

一个索引可以分成多个分片，分部在不同的机器上。那假设上面所说的10台机器中有一台发生故障了，在这台机器上的分片也就没了，就会导致索引损坏。为了解决索引高可用的问题，ES引入了副本机制，这里的副本指的就是分片的副本，分片的原始数据称为主分片，主分片和副本会放在不同的机器上，这样假设有一个分配丢失了，另外的分片可以作为后备。如果主分片的机器挂掉了，其中一个副本分片就会升级成主分片。同时，因为副本分片的工作和主分片是一样的，所以增加副本的数量可以提升查询性能。

2.7 IK分词器

分词：即把一段中文或者别的划分成一个个的关键字，我们在搜索时候会把自己的信息进行分词，会把数据库中或者索引库中的数据进行分词，然后进行一个匹配操作，默认的中文分词是将每个字看成一个词，比如“我爱狂神”会被分为"我"，“爱”，“狂”，“神” ，这显然是不符合要求的，所以我们需要安装中文分词器ik来解决这个问题。如果要使用中文，建议使用ik分词器

IK提供了两个分词算法： ik_ smart和ik_ max_ word ，其中ik_ smart为最少切分， ik_ max_ _word为最细粒度划分！

什么是IK分词器：

• 把一句话分词

• 两个分词算法：ik_smart（最少切分），ik_max_word（最细粒度划分）

【ik_smart】测试：

 GET _analyze
 {
   "analyzer"： "ik_smart"，
   "text"： "我是社会主义接班人"
 }
 ​
 //输出
 {
   "tokens" ： [
     {
       "token" ： "我"，
       "start_offset" ： 0，
       "end_offset" ： 1，
       "type" ： "CN_CHAR"，
       "position" ： 0
     }，
     {
       "token" ： "是"，
       "start_offset" ： 1，
       "end_offset" ： 2，
       "type" ： "CN_CHAR"，
       "position" ： 1
     }，
     {
       "token" ： "社会主义"，
       "start_offset" ： 2，
       "end_offset" ： 6，
       "type" ： "CN_WORD"，
       "position" ： 2
     }，
     {
       "token" ： "接班人"，
       "start_offset" ： 6，
       "end_offset" ： 9，
       "type" ： "CN_WORD"，
       "position" ： 3
     }
   ]
 }

【ik_max_word】测试：

 GET _analyze
 {
   "analyzer"： "ik_max_word"，
   "text"： "我是社会主义接班人"
 }
 //输出
 {
   "tokens" ： [
     {
       "token" ： "我"，
       "start_offset" ： 0，
       "end_offset" ： 1，
       "type" ： "CN_CHAR"，
       "position" ： 0
     }，
     {
       "token" ： "是"，
       "start_offset" ： 1，
       "end_offset" ： 2，
       "type" ： "CN_CHAR"，
       "position" ： 1
     }，
     {
       "token" ： "社会主义"，
       "start_offset" ： 2，
       "end_offset" ： 6，
       "type" ： "CN_WORD"，
       "position" ： 2
     }，
     {
       "token" ： "社会"，
       "start_offset" ： 2，
       "end_offset" ： 4，
       "type" ： "CN_WORD"，
       "position" ： 3
     }，
     {
       "token" ： "主义"，
       "start_offset" ： 4，
       "end_offset" ： 6，
       "type" ： "CN_WORD"，
       "position" ： 4
     }，
     {
       "token" ： "接班人"，
       "start_offset" ： 6，
       "end_offset" ： 9，
       "type" ： "CN_WORD"，
       "position" ： 5
     }，
     {
       "token" ： "接班"，
       "start_offset" ： 6，
       "end_offset" ： 8，
       "type" ： "CN_WORD"，
       "position" ： 6
     }，
     {
       "token" ： "人"，
       "start_offset" ： 8，
       "end_offset" ： 9，
       "type" ： "CN_CHAR"，
       "position" ： 7
     }
   ]
 }

用户也可以自定义分词内容：https://blog.csdn.net/trusause/article/details/79581210

3. 命令模式的使用

3.1 Rest风格说明

一种软件架构风格，而不是标准。更易于实现缓存等机制

method	url地址	描述
PUT	localhost:9200/索引名称/类型名称/文档id	创建文档(指定文档id)
POST	localhost:9200/索引名称/类型名称	创建文档（随机文档id）
POST	localhost:9200/索引名称/类型名称/文档id/_update	修改文档
DELETE	localhost:9200/索引名称/类型名称/文档id	删除文档
GET	localhost:9200/索引名称/类型名称/文档id	通过文档id查询文档
POST	localhost:9200/索引名称/类型名称/_search	查询所有的数据

创建索引

PUT /索引名/类型名(索引名高版本都不写了，都是_doc)/文档id

{请求体}

完成了自动添加了索引！数据也成功的添加了。

那么name这个字段用不用指定类型呢

指定字段的类型properties 就比如sql创表

获得这个规则！可以通过GET请求获得具体的信息

如果自己不设置文档字段类型，那么es会自动给默认类型

获取健康值

获取所有的信息

 GET _cat/indices?v

修改索引

修改我们可以还是用原来的PUT的命令，根据id来修改

但是如果没有填写的字段 会重置为空了 ，相当于java接口传对象修改，如果只是传id的某些字段，那其他没传的值都为空了。

2.还有一种update方法 这种不设置某些值 数据不会丢失

 POST /test3/_doc/1/_update
 {
   "doc":{
     "name":"212121"
   }
 }
 ​
 //下面两种都是会将不修改的值清空的
 ​
 POST /test3/_doc/1
 {
     "name":"212121"
 }
 POST /test3/_doc/1
 {
   "doc":{
     "name":"212121"
   }
 }

删除索引

关于删除索引或者文档的操作

通过DELETE命令实现删除，根据你的请求来判断是删除索引还是删除文档记录

3.2 关于文档的基本操作

3.2.1 基本操作

1、添加数据

PUT /psz/user/1
{
  "name": "psz",
  "age": 22,
  "desc": "偶像派程序员",
  "tags": ["暖","帅"]
}

2、获取数据

GEt psz/user/1
===============输出===========
{
  "_index" : "psz",
  "_type" : "user",
  "_id" : "1",
  "_version" : 1,
  "_seq_no" : 0,
  "_primary_term" : 1,
  "found" : true,
  "_source" : {
    "name" : "psz",
    "age" : 22,
    "desc" : "偶像派程序员",
    "tags" : [
      "暖",
      "帅"
    ]
  }
}

3、 更新数据PUT

4、更新数据，推荐POST _update

• 不推荐

POST psz/user/1
{
  "doc":{
    "name": "庞庞胖"    #后面信息会没有
  }
}

• 推荐！

POST psz/user/1/_update
{
  "doc":{
    "name": "庞庞胖"    #后面信息存在
  }
}

5、简单搜索 GET

GET psz/user/1

简单的条件查询：根据默认映射规则产生基本的查询

GET psz/user/_search?q=name:庞世宗

3.2.1 复杂查询

1、查询，参数使用JSON体

GET lkk/user/_search
{
  "query": {
    "match": {
      "name": "罗贤松"   //根据name匹配
    }  
  },
    "_source": ["name","age"],  //结果的过滤，只显示name和age
    "sort": [
    {
      "age": {
        "order": "desc" //根据年龄降序
    }
    }
  ],
    
  "from": 0, //分页：起始值，从0还是
  "size": 1  //返回多少条数据
}

• 之后只用java操作es时候，所有的对象和方法就是这里面的key

• 分页前端 /search/{current}/{pagesize}

2 、布尔值查询

• must(对应mysql中的and) ,所有条件都要符合

GET lkk/user/_search
{
  "query": {
    "bool": {
      "must": [  //相当于and
        {
          "match": {
            "name": "罗贤松"
          }
        },
        {
          "match": {
            "age": 22
          }
        }
          
      ]
    }
  }
}

• shoule(对应mysql中的or)

GET lkk/user/_search
{
  "query": {
    "bool": {
      "should": [ //should相当于or
        {
          "match": {
            "name": "罗贤松"
          }  
        },
        {
          "match": {
            "age": 22
          }
        }   
      ]
    }
  }
}

• must_not (对应mysql中的not)

• 过滤器

GET psz/user/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "match": {
            "name": "罗贤松"
          }
          
        }
      ],
      "filter": [
        {
          "range": {
            "age": {
              "gt": 20   //过滤年龄大于20的
            }
          }
        }
      ]
    }
  }
}

3、精确查询

• trem查询是直接通过倒排索引指定的词条进行精确的查找的。

关于分词：

trem，直接查询精确地

match，会使用分词器解析

关于类型：

text: 分词器会解析

keywords: 不会被拆分

4、高亮查询

GET psz/user/_search
{
  "query": {
    "match": {
      "name": "罗贤松"
    }
  },
  "_source": ["name","age"],
  "sort": [
    {
      "age": {
        "order": "desc"
      }
    }
  ],
  "highlight": //高亮
  {
    "pre_tags": "<P>",   //自定义高亮
    "post_tags": "</P>", 
    "fields": {
      "name":{}  //自定义高亮区域
    }  
  }
}

4. springboot集成

4.1 引入依赖包

创建一个springboot的项目 同时勾选上springboot-web的包以及Nosql的elasticsearch的包

如果没有就手动引入

<!--es客户端-->
<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
    <version>7.6.2</version>
</dependency>

<!--springboot的elasticsearch服务-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>

注意下spring-boot的parent包内的依赖的es的版本是不是你对应的版本

不是的话就在pom文件下写个properties的版本

<!--这边配置下自己对应的版本-->
<properties>
    <java.version>1.8</java.version>
    <elasticsearch.version>7.6.2</elasticsearch.version>
</properties>

4.2 注入RestHighLevelClient 客户端

@Configuration
public class ElasticSearchClientConfig {
    @Bean
    public RestHighLevelClient restHighLevelClient(){
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("127.0.0.1",9200,"http"))
        );
        return client;
    }
}

4.3 索引的增、删、是否存在

//测试索引的创建
@Test
void testCreateIndex() throws IOException {
    //1.创建索引的请求
    CreateIndexRequest request = new CreateIndexRequest("lkk_index");
    //2客户端执行请求，请求后获得响应
    CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
    System.out.println(response);
}

//测试索引是否存在
@Test
void testExistIndex() throws IOException {
    //1.创建索引的请求
    GetIndexRequest request = new GetIndexRequest("lkk_index");
    //2客户端执行请求，请求后获得响应
    boolean exist =  client.indices().exists(request, RequestOptions.DEFAULT);
    System.out.println("测试索引是否存在-----"+exist);
}

//删除索引
@Test
void testDeleteIndex() throws IOException {
    DeleteIndexRequest request = new DeleteIndexRequest("lkk_index");
    AcknowledgedResponse delete = client.indices().delete(request,RequestOptions.DEFAULT);
    System.out.println("删除索引--------"+delete.isAcknowledged());
}
123456789101112131415161718192021222324252627

4.4 文档的操作

 //测试添加文档
     @Test
     void testAddDocument() throws IOException {
         User user = new User("lisen",27);
         IndexRequest request = new IndexRequest("lkk_index");
         request.id("1");
         //设置超时时间
         request.timeout("1s");
         //将数据放到json字符串
         request.source(JSON.toJSONString(user), XContentType.JSON);
         //发送请求
         IndexResponse response = client.index(request,RequestOptions.DEFAULT);
         System.out.println("添加文档-------"+response.toString());
         System.out.println("添加文档-------"+response.status());
 //        结果
 //        添加文档-------IndexResponse[index=lkk_index,type=_doc,id=1,version=1,result=created,seqNo=0,primaryTerm=1,shards={"total":2,"successful":1,"failed":0}]
 //        添加文档-------CREATED
     }
 ​
     //测试文档是否存在
     @Test
     void testExistDocument() throws IOException {
         //测试文档的 没有index
         GetRequest request= new GetRequest("lkk_index","1");
         //没有indices()了
         boolean exist = client.exists(request, RequestOptions.DEFAULT);
         System.out.println("测试文档是否存在-----"+exist);
     }
 ​
     //测试获取文档
     @Test
     void testGetDocument() throws IOException {
         GetRequest request= new GetRequest("lkk_index","1");
         GetResponse response = client.get(request, RequestOptions.DEFAULT);
         System.out.println("测试获取文档-----"+response.getSourceAsString());
         System.out.println("测试获取文档-----"+response);
 ​
 //        结果
 //        测试获取文档-----{"age":27,"name":"lisen"}
 //        测试获取文档-----{"_index":"lkk_index","_type":"_doc","_id":"1","_version":1,"_seq_no":0,"_primary_term":1,"found":true,"_source":{"age":27,"name":"lisen"}}
 ​
     }
 ​
     //测试修改文档
     @Test
     void testUpdateDocument() throws IOException {
         User user = new User("李逍遥", 55);
         //修改是id为1的
         UpdateRequest request= new UpdateRequest("lkk_index","1");
         request.timeout("1s");
         request.doc(JSON.toJSONString(user),XContentType.JSON);
 ​
         UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
         System.out.println("测试修改文档-----"+response);
         System.out.println("测试修改文档-----"+response.status());
 ​
 //        结果
 //        测试修改文档-----UpdateResponse[index=lkk_index,type=_doc,id=1,version=2,seqNo=1,primaryTerm=1,result=updated,shards=ShardInfo{total=2, successful=1, failures=[]}]
 //        测试修改文档-----OK
 ​
 //        被删除的
 //        测试获取文档-----null
 //        测试获取文档-----{"_index":"lisen_index","_type":"_doc","_id":"1","found":false}
     }
 ​
 ​
     //测试删除文档
     @Test
     void testDeleteDocument() throws IOException {
         DeleteRequest request= new DeleteRequest("lkk_index","1");
         request.timeout("1s");
         DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
         System.out.println("测试删除文档------"+response.status());
     }
 ​
     //测试批量添加文档
     @Test
     void testBulkAddDocument() throws IOException {
         ArrayList<User> userlist=new ArrayList<User>();
         userlist.add(new User("cyx1",5));
         userlist.add(new User("cyx2",6));
         userlist.add(new User("cyx3",40));
         userlist.add(new User("cyx4",25));
         userlist.add(new User("cyx5",15));
         userlist.add(new User("cyx6",35));
 ​
         //批量操作的Request
         BulkRequest request = new BulkRequest();
         request.timeout("1s");
 ​
         //批量处理请求
         for (int i = 0; i < userlist.size(); i++) {
             request.add(
                     new IndexRequest("lkk_index")
                             .id(""+(i+1))
                             .source(JSON.toJSONString(userlist.get(i)),XContentType.JSON)
             );
         }
         BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
         //response.hasFailures()是否是失败的
         System.out.println("测试批量添加文档-----"+response.hasFailures());
 ​
 //        结果:false为成功 true为失败
 //        测试批量添加文档-----false
     }
 ​
 ​
     //测试查询文档
     @Test
     void testSearchDocument() throws IOException {
         SearchRequest request = new SearchRequest("lkk_index");
         //构建搜索条件
         SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
         //设置了高亮
         sourceBuilder.highlighter();
         //term name为罗贤松的
         TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name", "cyx1");
         sourceBuilder.query(termQueryBuilder);
         sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
 ​
         request.source(sourceBuilder);
         SearchResponse response = client.search(request, RequestOptions.DEFAULT); 
​ 
        System.out.println("测试查询文档-----"+JSON.toJSONString(response.getHits())); 
        System.out.println("====================="); 
        for (SearchHit documentFields : response.getHits().getHits()) { 
            System.out.println("测试查询文档--遍历参数--"+documentFields.getSourceAsMap()); 
        } 
​ 
//        测试查询文档-----{"fragment":true,"hits":[{"fields":{},"fragment":false,"highlightFields":{},"id":"1","matchedQueries":[],"primaryTerm":0,"rawSortValues":[],"score":1.8413742,"seqNo":-2,"sortValues":[],"sourceAsMap":{"name":"cyx1","age":5},"sourceAsString":"{\"age\":5,\"name\":\"cyx1\"}","sourceRef":{"fragment":true},"type":"_doc","version":-1}],"maxScore":1.8413742,"totalHits":{"relation":"EQUAL_TO","value":1}} 
//        ===================== 
//        测试查询文档--遍历参数--{name=cyx1, age=5} 
    }