07、ElasticSearch

Es 学习

## 搭建[#](https://www.cnblogs.com/boise/p/18104280#%E6%90%AD%E5%BB%BA)

### 前置条件[#](https://www.cnblogs.com/boise/p/18104280#%E5%89%8D%E7%BD%AE%E6%9D%A1%E4%BB%B6)

下文的所有功能均按照这些版本开发和描述**，电脑版本 Win11**

* Java 的 JDK：java version "1.8.0\_181"，安装 ES 之前需要先准备好 Java 的环境，因为 Elasticsearch 使用 Java 构建。
* ElasticSearch 的安装包：elasticsearch-8.8.1-windows-x86\_64
* Node.js 环境：Kibana 需要 node.js 环境，判断是否有安装 node。可以在 cmd 输入 node-v
* Kibana 的安装包：kibana 的版本与 ES 的版本需要完全一致，如果不一致则无法正常使用
* IK 分词器：版本与 ES 的版本需要完全一致，如果不一致则无法正常使用

### 安装 ElasticSearch[#](https://www.cnblogs.com/boise/p/18104280#%E5%AE%89%E8%A3%85elasticsearch)

#### **[最新安装包地址](https://www.elastic.co/cn/downloads/elasticsearch)**[#](https://www.cnblogs.com/boise/p/18104280#%E6%9C%80%E6%96%B0%E5%AE%89%E8%A3%85%E5%8C%85%E5%9C%B0%E5%9D%80)

#### [更多版本安装包地址](https://www.elastic.co/cn/downloads/past-releases)[#](https://www.cnblogs.com/boise/p/18104280#%E6%9B%B4%E5%A4%9A%E7%89%88%E6%9C%AC%E5%AE%89%E8%A3%85%E5%8C%85%E5%9C%B0%E5%9D%80)

#### 安装教程[#](https://www.cnblogs.com/boise/p/18104280#%E5%AE%89%E8%A3%85%E6%95%99%E7%A8%8B)

1. 将下载好的 Zip 文件解压到自定义的目录，建议文件夹名称为英文
   **解压后的文件夹构成：**
   * bin：存放关于命令、ES 服务启动/关闭的文件夹（elasticsearch.bat）
   * config：存放配置 ES 的文件夹（elasticsearch.yml）
   * lib：存放 Es 的 jar 包依赖库
   * logs：日志存放
   * modules：es 依赖的组件，在启动的时候加载
   * plugins：存放第三方插件，如 IK 分词器
2. 双击 bin 文件夹中的 elasticsearch.bat 文件，会弹出一个控制台窗体，等待大约 1 分钟左右，启动后不要关闭窗体，关闭窗体代表关闭 ES 服务。
   **注意：**
   * 首次启动的时候，ES 会默认启用身份验证和授权，会在控制台打印出默认的用户名和密码，如果打印的信息过多，可以全文搜索 password 这个字段，后面那串就是用户名和密码，记得把他保存下来
3. 在浏览器访问 http://localhost:9200，如果能正常访问，要求输入密码或返回一大段 json 则代表启动成功，如果提示失败，请查看控制台的错误信息
   **注意：**启动成功后会有 2 个端口一个是 9200，为客户端访问端口，http 协议。一个是 9300，集群节点间通讯端口，接受 tcp 协议。
4. 可以将 ElasticSearch 安装为在后台运行或在启动时自动启动的服务，无需用户交互
   * 在控制台 cd 到 bin 文件夹目录，执行命令 elasticsearch-service.bat install（如果之前有注册，install 改为 remove）
   * 继续执行命令 elasticsearch-service.bat manager，选择 java-勾选 use default，选择 general，下面的 startup type 改为 automatic，然后点击 start
   * 打开控制面板（win+r-services.msc），查看服务是否成功运行

#### 常用配置（elasticsearch.yml 文件）[#](https://www.cnblogs.com/boise/p/18104280#%E5%B8%B8%E7%94%A8%E9%85%8D%E7%BD%AEelasticsearchyml%E6%96%87%E4%BB%B6)

* 修改索引存放位置
  增加节点：path.data: 自定义目录，
* 修改日志存放位置
  增加节点：path.logs: 自定义目录
* 允许跨域
  增加节点：http.cors.enabled: true ，http.cors.allow-origin: "\*"

### 安装 Kibana[#](https://www.cnblogs.com/boise/p/18104280#%E5%AE%89%E8%A3%85kibana)

#### [最新安装包地址](https://www.elastic.co/cn/downloads/kibana)[#](https://www.cnblogs.com/boise/p/18104280#%E6%9C%80%E6%96%B0%E5%AE%89%E8%A3%85%E5%8C%85%E5%9C%B0%E5%9D%80-1)

**注意：**Kibana 需要 Node.js 的环境，需要和 ES 的版本一致，否则无法使用，下载的时候确定好对应的关系！！！！！！！！！

#### [更多版本安装包地址](https://www.elastic.co/cn/downloads/past-releases#kibana)[#](https://www.cnblogs.com/boise/p/18104280#%E6%9B%B4%E5%A4%9A%E7%89%88%E6%9C%AC%E5%AE%89%E8%A3%85%E5%8C%85%E5%9C%B0%E5%9D%80-1)

#### 安装教程[#](https://www.cnblogs.com/boise/p/18104280#%E5%AE%89%E8%A3%85%E6%95%99%E7%A8%8B-1)

1. 将下载好的 Zip 文件解压到自定义的目录，建议文件夹名称为英文
2. 双击 bin 文件夹下的 kibana.bat，成功启动后，会出现提示，在浏览器输入 http://localhost:5601/，如果能正常出现界面则代表启动成功，注意，需要先启动 ES。
3. kibana 默认根据 es 服务启动了身份认证，所以按照提示获取 token 来注册
   * 首先，在 es 的 bin 文件夹下执行命令 elasticsearch-create-enrollment-token.bat --scope kibana 获取密钥
   * 第二，在 kibana 的 bin 文件夹下执行命令 kibana-verification-code.bat，获取验证码
   * 第三，输入 es 第一次启动的时候给的默认账户和密码

#### 常用配置（config 文件夹下的 kibana.yml）[#](https://www.cnblogs.com/boise/p/18104280#%E5%B8%B8%E7%94%A8%E9%85%8D%E7%BD%AEconfig%E6%96%87%E4%BB%B6%E5%A4%B9%E4%B8%8B%E7%9A%84kibanayml)

* 修改系统语言为中文
  修改节点：i18n.locale: "zh-CN"
* 配置 ES 端口
  修改节点：elasticsearch.url: "[https://localhost:9200](https://localhost:9200/)"

### 配置中文分词器[#](https://www.cnblogs.com/boise/p/18104280#%E9%85%8D%E7%BD%AE%E4%B8%AD%E6%96%87%E5%88%86%E8%AF%8D%E5%99%A8)

#### [下载地址](https://github.com/medcl/elasticsearch-analysis-ik)[#](https://www.cnblogs.com/boise/p/18104280#%E4%B8%8B%E8%BD%BD%E5%9C%B0%E5%9D%80)

版本与 ES 的版本需要完全一致，如果不一致则无法正常使用

#### 安装[#](https://www.cnblogs.com/boise/p/18104280#%E5%AE%89%E8%A3%85)

1. 在 ES 的 plugins 创建文件夹 ik，将配置文件之类的复制进去
2. 重启 ES 服务，ES 的控制台会打印 loaded plugin [analysis-ik]这段信息即代表成功

#### 介绍/注意[#](https://www.cnblogs.com/boise/p/18104280#%E4%BB%8B%E7%BB%8D%E6%B3%A8%E6%84%8F)

##### 介绍分词器作用

ES 分词的操作是在添加数据的时候完成的！同样的，在查询索引数据的时候，也会先根据查询的关键词进行分词然后匹配， 在分词后，会在底层产生倒排索引，倒排索引就是 Es 能提供快速查询的核心，倒排索引表包含： 单词 id，单词，文档频率（在整个索引中有多少个文档包含了单词），倒排列表 < 文档 id，出现的次数，位置 >

1. ik\_max\_word:最细粒度的分割
   比如分割“我喜欢吃好吃的苹果”分割为“我喜欢、好吃、好吃的苹果、吃的苹果、苹果、喜欢、我”等，会穷尽各种可能的组合，建议添加数据的时候使用
2. ik\_smart: 会做最粗粒度的分割
   比如分割“我喜欢吃好吃的苹果”分割为“我喜欢吃好吃的苹果、好吃的苹果”，建议查询数据的时候使用

##### 注意

由于 ES 中（5.0 以后），文本类型分为 Text 和 KeyWord2 种类型，其中对于 Text 会进行分词处理，一般用于存储长文本，不能用于过滤，排序，聚合等操作，一般使用全文搜索，会在倒排索引中插入数据，对于 KeyWord 不会分词，一般用于短文本，用于过滤，排序，聚合等操作，一般使用术语级查询，会生成一个带有.keyword 的子字段用于保存数据

#### Nest 使用[#](https://www.cnblogs.com/boise/p/18104280#nest%E4%BD%BF%E7%94%A8)

调试分词器 Demo，判断 ik 分词器是否起作用了

```C#
/// <summary>
        /// 调试分词器
        /// </summary>
        /// <param name="value"></param>
        public async Task<dynamic> TestAnalyze(string value)
        {
            // 分词器包含standard，whitespace
            AnalyzeResponse analyzeResponse = await _elasticClient.Indices.AnalyzeAsync(a => a
                                                                    .Tokenizer("ik_max_word") // 指定的分词器
                                                                    .Filter("lowercase", "stop") // 指定token处理器，小写/去除停用词
                                                                    .Text(value) // 需要处理的文本                                                
                                                         );

return analyzeResponse.Tokens;
        }
```

配置分词器到指定模型上 Demo

配置后，

```c#
[Text(Name = nameof(Content), Index = true, Analyzer = "ik_max_word")]
 public string? Content { get; set; }
```

#### 常用配置文件[#](https://www.cnblogs.com/boise/p/18104280#%E5%B8%B8%E7%94%A8%E9%85%8D%E7%BD%AE%E6%96%87%E4%BB%B6)

在 config 文件夹下面很多的文件

* main.dic / extra\_main.dic：储存的中文分词/拓展的中文分词，只要是文本在里面的词，都会被分词
* surname.dic：存储的姓氏分词，如刘、夏、莫等
* surname.dic：存储的后缀分词，如省、市、海、湖、巷
* quantifier.dic：存储的量词分词，如年、月、平米、千米、男、女、眼等
* preposition.dic：存储的介词分词，如但、的、又、却等
* extra\_single\_word.dic：存储的常见单字分词
* extra\_single\_word\_low\_freq.dic：存储的少见的分词，比如一些繁体字或者文言文字体，当然我们也可以把一些网络用语或者谐音字放在这里面
* extra\_single\_word\_full.dic：存储的全部常见单字分词
* extra\_stopword.dic / stopword.dic：拓展 / 英文停用词字典
  为，在字典内配置的词语不会出现在分词器中，比如“和”、“虽然”、“啊”等语气助词不需要建立倒排索引就可以放在拓展停用词字典里面，因为默认不启用 extra\_stopword.dic，所以需要在 ik 的配置文件 IKAnalyzer.cfg.xml 中配置 extra\_stopword.dic
* remote\_ext\_dict / remote\_ext\_stopwords：远程拓展字典 / 远程停用字典
  配置在几点节点
  可以将需要自动更新的热词放在一个 UTF-8 编码的.txt 文件里，放在 nginx 或其他简单的 http 服务器下，当.txt 文件修改时，http 服务器会在客户端请求该文件时自动返回相应的 Last-Modified 和 ETag。还可以做一个工具来从业务系统中提取相关词汇，并更新这个 .txt 文件。

```json
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
	<comment>IK Analyzer 扩展配置</comment>
	
	<entry key="ext_dict"></entry>
	 
	<entry key="ext_stopwords"></entry>
	
	
	
	
</properties>
```

## 数据结构：[#](https://www.cnblogs.com/boise/p/18104280#%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84)

由于 ES 是面向文档的，

### Index 索引：[#](https://www.cnblogs.com/boise/p/18104280#index%E7%B4%A2%E5%BC%95)

这个索引不要代入到我们数据库当中的索引

**注意！！！！**

* 索引的名称必须为**小写**！
* 一个集群可以有多个索引！
* 索引具有 mapping 和 setting 的概念，mapping 决定索引中 Document 的映射关系，setting 决定索引的数据分布的配置！

### Document 文档：[#](https://www.cnblogs.com/boise/p/18104280#document%E6%96%87%E6%A1%A3)

存储在 Index 中的单元，一个 Document 代表一行数据（Json 的形式存储），一个文档除了保存我们放入的数据之外，还会额外保存一些元数据

注意！！！

* 文档包含字段，每个字段类型都有数据类型，如布尔、数字、字符串等，如果在创建的时候没有指定，默认自动匹配！
* 每个文档都有主键，默认拿名称为 Id 的字段，也可以手动指定
* 文档除了保存放入的数据外，还会保存一些额外的元数据

```json
{
  "_index": "postindex", // 归属索引
  "_id": "443140808372293", // 主键Id
  "_version": 1, // 版本，即代表这条数据有无被修改过，如果被修改了则+1，在Es中，是没有修改的概念的，他是删除了在增加一条
  "_score": 1, // 相关性打分，这个作用可以在后续的文章中介绍
  "fields": {   
    "Title": [
      "测试"
    ],
    "Id": [
      443140808372293
    ]
  }
}
```

### Shard 分片：[#](https://www.cnblogs.com/boise/p/18104280#shard%E5%88%86%E7%89%87)

分片的原因是，当文档的数量太大的时候，响应可能会很慢，所以我们在创建索引的时候，确定好分片数量，比如 3 个分片，每个分片放在不同的服务器中，那么当我们往索引中插入一条文档的时候，ES 会将这个文档分为很多部分，分别放在不同的分片中，当你发送请求的时候，ES 会分别从 3 个分片中查询数据，然后组合在一起返回给用户。

分片分为主分片和副本分片，主分片用于主要的查询和存储功能，副本分片用于存储数据，这样当主分片挂掉了，副本分片能及时顶上去工作，一个索引最多拥有 5 个主分片，一个主分片可以有多个副本分片，在创建完索引后，主分片的数量不可更改，副本数量可以调整。

因为插入文档的时候，先插入主分片然后再插入副分片，那么我们可以就考虑主存副读来实现读写分离。

如果一个索引的 Index 大小不会超过 20GB，那么无需考虑多个分片，设置为一个主分片，1/2 的副本分片即可。

## 字段数据类型[#](https://www.cnblogs.com/boise/p/18104280#%E5%AD%97%E6%AE%B5%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B)

通常情况下，如果我们创建 Index 的时候指定了自动映射，那么 ES 会自动完成 ES 与 C#数据类型的映射关系

只介绍常用类型，更多类型查看官网

**特性：Nest 中的特性**

| ES 数据类型          | C#中的数据类型 | 注意事项                                                                                                                                                           |
| ---------------------- | ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Text                 | string         | 分词器于 Text 会进行分词处理，一般用于存储长文本，不能用于过滤，排序，聚合等操作，可以通过特性 **TextAttribute** 指定属性映射为 Text 类型                      |
| KeyWord              | string         | 分词器对于 KeyWord 不会分词，一般用于短文本，用于过滤，排序，聚合等操作，可以通过特性 **KeywordAttribute** 指定属性映射为 KeyWord 类型。                       |
| long                 | long           | long 类型可能会查询后返回的数据存在精度丢失的问题，长度最好不能超过 16，否则会丢失后面，存是没问题的，查就有问题了，所以当超过 16 位的时候，最好设置他为 keyword。 |
| doubel 和 float 类型 | double/float   | 使用聚合函数 sum 等查询的时候会出现精度丢失的问题                                                                                                                  |
| date                 | DateTime       | ES 同步时间与真实时间相差 8 个小时，因为 ES 采取的格式位 UTC，如果是时间还是推荐存为 long 类型时间戳                                                               |
| boolean              | bool           | 布尔类型，                                                                                                                                                         |
| Array                | List array     | 在 Elasticsearch 中，没有专用的 `array` 数据类型。默认情况下，任何字段都可以包含零个或多个值，但是数组中的所有值必须具有相同的数据类型。例如：                   |
| integer              | int            |                                                                                                                                                                    |
| short                | short          |                                                                                                                                                                    |
| byte                 | byte           |                                                                                                                                                                    |
| binary               |                | 可以用来存储 Base64 字符串，属于这个类型的字段默认不可以被搜索到                                                                                                   |
| object               | object         |                                                                                                                                                                    |
| nested               |                | 嵌套类型                                                                                                                                                           |

## 安装包 Nest[#](https://www.cnblogs.com/boise/p/18104280#%E5%AE%89%E8%A3%85%E5%8C%85nest)

在 NetCore 我们我们操作 ElasticSearch 通常通过 **Nest** 这个包

**版本：**7.17.5

> NEST 是一个高级 Elasticsearch .NET 客户端，它仍然与原始 Elasticsearch API 非常接近。所有请求和响应都通过类型公开，使其成为快速启动和运行的理想选择。
> 在幕后，NEST 使用 Elasticsearch.Net 低级客户端来分派请求和响应，使用和扩展 Elasticsearch.Net 中的许多类型。低级别客户端本身仍然通过该属性暴露在高级客户端上。

## 连接池：获取 ElasticClient[#](https://www.cnblogs.com/boise/p/18104280#%E8%BF%9E%E6%8E%A5%E6%B1%A0%E8%8E%B7%E5%8F%96elasticclient)

### 概念[#](https://www.cnblogs.com/boise/p/18104280#%E6%A6%82%E5%BF%B5)

在了解 IElasticClient 之前，我们先了解一下，ES 的连接池的概念。

> 连接池是一种内部机制，负责注册集群中有哪些节点以及哪些 NEST 可用于发出客户端调用。尽管有这个名称，NEST 中的连接池并不像您在使用 ADO.Net 与数据库交互时所熟悉的连接池 ；例如，NEST 中的连接池不负责管理与 Elasticsearch 的 TCP 连接的底层池，这是由 Desktop CLR 中的 ServicePointManager 处理的。
> 
> 那么，NEST 中的连接池负责什么呢？它负责管理 Elasticsearch 集群中可以建立连接的节点，并且有一个的实例 IConnectionPool 与 的实例关联 ConnectionSettings。由于建议在应用程序的生命周期内使用单个客户端和连接设置实例，因此单个连接池实例的生命周期也将与应用程序的生命周期绑定。

简单来说，ES 的连接池不是用来管理客户端与 ES 的连接的，而是用于管理 ES 可以连接的节点列表，比如 ES 集群有 2 个节点，那么 ES 的连接池就有 2 个连接。当客户端发送查询等请求的时候，会从连接池中取得一个状态比较好的稳定的节点连接来进行操作，如果节点因为死机、断网等原因，没有办法提供服务的时候，连接池就会标记该节点为死节点（可通过配置尝试重连），所以 ES 的连接池是用来管理节点的而非连接的。

**ConnectionPool 和 ConnectionSettings 是配套使用的，一个 pool 对应一个 settings**

连接池一共有 5 种：

* 单节点连接池：SingleNodeConnectionPool
* 云连接池：CloudConnectionPool
* 静态连接池：StaticConnectionPool
* 嗅探连接池：SniffingConnectionPool
* 粘性连接池：

### 单节点连接池[#](https://www.cnblogs.com/boise/p/18104280#%E5%8D%95%E8%8A%82%E7%82%B9%E8%BF%9E%E6%8E%A5%E6%B1%A0)

**适用场景：**当你的节点只有一个的时候，那么请采用单节点连接池

**注意：**ES 官方的建议是将 ElasticClient 注册为单例模式，因为 ElasticClient 是线程安全的，为什么要注册为单例呢，是为了缓存 ConnectionSettings。且 SingleNodeConnectionPool 不会标记连接是否为死结点（**即不会触发嗅探和 ping 操作**），默认永远调用这个节点的连接。

**demo：**

单节点应用池一共有 2 种写法**（ES 官方推荐使用第一种写法）**

* 第一种写法：需要显示的将连接池传递给 ConnectionSettings 的构造函数，这样做的目的是为了让所有的请求统一通过连接池来完成调用
* 第二种写法：无需传递 ConnectionSettings，通过 Url 来连接到 ES，所有的请求也由 Uri 来发起调用，而非连接池。这种写法内部实现依旧采用 SingleNodeConnectionPool 实现

```c#
using Nest;
using Elasticsearch.Net;
namespace Test
{
    public class ElasticSearchHelper : IElasticSearchHelper
    {
        // 实现获取ElasticClient的方法
        public IElasticClient GetClient()
        {
            // Es节点连接
            Uri uri = new("http://localhost:9200");
            #region 第一种
            // 构造单节点应用池
            SingleNodeConnectionPool pool = new(uri);
            // 构造配置文件
            ConnectionSettings settings = new(pool);
            // 构造连接池
            ElasticClient client1 = new(settings);
            #endregion

#region 第二种
            // 直接传入uri
            ElasticClient client2 = new(uri);
            #endregion
            return client1;
        }
    }
}
```

### 静态连接池[#](https://www.cnblogs.com/boise/p/18104280#%E9%9D%99%E6%80%81%E8%BF%9E%E6%8E%A5%E6%B1%A0)

**ping 操作：**ping 操作指的是 ES 会定期向节点发送 ping 请求，如果节点未响应则将节点连接移除连接池或标记为死节点，以达到集群的稳定性和可用性。

**适用场景：**如果您有一个已知的小型集群并且不想启用嗅探来找出集群拓扑，那么静态连接池非常有用。

**注意：**静态连接池不支持嗅探操作，但是支持配置 ping 操作来检测连接是否为死结点

**demo：**

```C#
using Nest;
using Elasticsearch.Net;
namespace Test
{
    public class ElasticSearchHelper : IElasticSearchHelper
    {
        // 实现获取ElasticClient的方法
        public IElasticClient GetClient()
        {
            #region 第一种使用uri来
            Uri[] uris = new Uri[] { new Uri("http://localhost:9200"), new Uri("http://localhost:9100") };
            // 构建静态连接池
            StaticConnectionPool pool1 = new(uris);
            // 构建配置文件
            ConnectionSettings settings1 = new(pool1);
            // 返回客户端
            return new ElasticClient(settings1);
            #endregion

#region 第二种使用node
            Node[] nodes = new Node[] { new Uri("http://localhost:9200"), new Uri("http://localhost:9100") };
            // 构建静态连接池
            StaticConnectionPool pool2 = new(uris);
            // 构建配置文件
            ConnectionSettings settings2 = new(pool2);
            // 返回客户端
            return new ElasticClient(settings2);
            #endregion
        }
    }
}
```

### 嗅探连接池[#](https://www.cnblogs.com/boise/p/18104280#%E5%97%85%E6%8E%A2%E8%BF%9E%E6%8E%A5%E6%B1%A0)

**嗅探：**嗅探是指的 ES 会主动嗅探整个集群的状态，获取集群中的节点并把他们添加到客户端中，好处就是无需手动配置所有节点，ES 会自动查找、更新节点的状态。**嗅探只在设置为 true 的时候启用。**

**适用场景：**从 `StaticConnectionPool` 嗅探连接池派生的池允许在运行时重新播种。它带来了非常小的开销 `ReaderWriterLockSlim` 来确保线程安全。

**注意：**支持嗅探操作和 ping 操作，建议节点结合使用已知的集合

**demo：**

```C#
using Nest;
using Elasticsearch.Net;
namespace Test
{
    public class ElasticSearchHelper : IElasticSearchHelper
    {
        // 实现获取ElasticClient的方法
        public IElasticClient GetClient()
        {
            // 获取端口范围
            var uris = Enumerable.Range(9200, 5).Select(port => new Uri($"http://localhost:{port}"));
            // 构建嗅探连接池
            SniffingConnectionPool pool = new(uris);
            ConnectionSettings settings = new(pool);
            return new ElasticClient(settings);

// 使用node
            var nodes = uris.Select(u => new Node(u));
            var pool2 = new SniffingConnectionPool(nodes);
            var client1 = new ElasticClient(new ConnectionSettings(pool2));
            return client1;
        }
    }
}
```

## 连接配置：ConnectionSettings[#](https://www.cnblogs.com/boise/p/18104280#%E8%BF%9E%E6%8E%A5%E9%85%8D%E7%BD%AEconnectionsettings)

> 使用 Elasticsearch.Net 和 NEST 连接到 Elasticsearch 很容易，但您完全有可能想要更改默认连接行为。有许多配置选项可用于 ConnectionConfiguration 低级别客户端和 ConnectionSettings 高级客户端，可用于控制客户端与 Elasticsearch 的交互方式。

在上文中，我们反复提到了这个类，这个类就是用来配置一些我们一些连接行为。

以下 settings 指的是 ConnectionSettings 的实例，配置并不完整，我只列举大概所用到的。

| 方法                                                              | 作用                                                                                                                                                                                                                                   | 备注                                                                                                                              | 是否为常用配置 |
| ------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | ---------------- |
| settings.RequestTimeout(TimeSpan.FromSeconds(15));                | 允许连接超时时间                                                                                                                                                                                                                       | 单位毫秒，默认 60                                                                                                                 | √             |
| settings.ConnectionLimit(80);                                     | 限制可以向端点打开的并发连接数。                                                                                                                                                                                                       | 默认为 80                                                                                                                         | √             |
| settings.DisablePing(false);                                      | 禁止 ping，当一个节点第一次使用时，或者当它被标记为死亡后第一次使用时，会向该节点发送一个超时时间非常低的 ping，以确保当它仍然死亡时，它会以最快的速度报告它。可能的。如果您希望在可能较慢的原始请求上失败。                           | 默认 false                                                                                                                        | √             |
| settings.PingTimeout(TimeSpan.FromSeconds(15));                   | 设置 ping 请求的默认 ping 超时（以毫秒为单位），用于确定节点是否处于活动状态。Ping 应尽快失败。                                                                                                                                        | 单位毫秒，给的值不应该太大。                                                                                                      |                |
| settings.DefaultIndex(indexName);                                 | 配置这个连接默认使用使用操作的的索引。                                                                                                                                                                                                 | indexName 指的是索引名称                                                                                                          | √             |
| settings.EnableDebugModel();                                      | 配置后，可以在 ISearchResponse.ApiCall.DebugInformation 查看更多的调试信息（就是我们使用查询后返回的结果）                                                                                                                             | 与 DisableDirectStreaming()或者 PrettyJson()使用，可以获取完整的报错信息。                                                        | √             |
| settings.DisableDirectStreaming(true);                            | 禁止流处理，确保响应字节始终可用 `ElasticsearchResponse`                                                                                                                                                                         | 默认为 false，设置为 true 的时候，，这可能会导致响应首先缓冲在内存中，从而可能影响性能。                                          | √             |
| settings.PrettyJson(true);                                        | 强制所有请求附加 ?pretty=true 查询字符串参数，这个参数是用来决定 ES 默认返回 json                                                                                                                                                      | 默认为 false                                                                                                                      | √             |
| settings.DefaultFieldNameInferrer(p => p);                        | 采用模型（我们自己编写的 Index 实体类）的属性名称，因为 Nest 默认默认是使用驼峰属性名称，即首字母小写，如果我们在使用查询的时候，传入指定字段名称，比如 Name，由于 Nest 默认是 name，就可能导致翻译的 DSL 语句不是我们想要的正确翻译。 |                                                                                                                                   | √             |
| settings.DefaultMappingFor(p => p)                                | 指定如何为给定的 CLR 类型推断映射。该映射可以推断给定 CLR 类型的索引、id 和关系名称，以及控制 CLR 属性的序列化行为。                                                                                                                   |                                                                                                                                   |                |
| settings.DefaultDisableIdInference(true);                         | 禁用 ES 自动推断 ID，默认 ES 会采用属性名称为 Id 的字段作为主键，我们可以设置为 true。并结合[ElasticsearchType(IdProperty = "自定义 ID 名称")]这个特性来设置 Index 的主键                                                              |                                                                                                                                   |                |
| settings.BasicAuthentication("用户名", "密码");                   | 与所有请求一起发送到 Elasticsearch 的基本身份验证凭据                                                                                                                                                                                  |                                                                                                                                   |                |
| settings.EnableHttpCompression(false);                            | 启用 gzip 压缩请求和响应                                                                                                                                                                                                               | 默认为 false，需要在 Elasticsearch 上配置 http 压缩才能使用此功能                                                                 |                |
| settings.GlobalHeaders();                                         | 设置每个请求需要携带的请求头                                                                                                                                                                                                           |                                                                                                                                   |                |
| settings.GlobalQueryStringParameters(nameValue);                  | 设置全局查询字符串，比如我们常用的假删除过滤器。设置后每个查询都会携带此条件                                                                                                                                                           | 完整用法：NameValueCollection nameValue = new();nameValue.Add("Key", "Value");settings.GlobalQueryStringParameters(nameValue); |                |
| settings.IncludeServerStackTraceOnError(true);                    | 强制所有请求附加 ?error\_trace=true 查询字符串参数，导致 Elasticsearch 返回堆栈跟踪作为序列化异常的一部分                                                                                                                              | 默认为 false                                                                                                                      |                |
| settings.MaximumRetries(1);                                       | 给定请求的最大重试次数                                                                                                                                                                                                                 |                                                                                                                                   |                |
| settings.OnRequestCompleted(apiCallDetails =>{// 回调事件});   | 注册 ES 服务端接收到了请求所需要触发的事件。                                                                                                                                                                                           | 这个功能可以实现日志记录啊之类的功能。可以注册多个回调事件                                                                        |                |
| settings.OnRequestDataCreated(apiCallDetails =>{// 回调事件}); | 注册在 ES 服务端处理完数据后，即响应的时候被触发的事件。                                                                                                                                                                               | 可以注册多个回调事件                                                                                                              |                |