es--基础--9.2--SpringBoot注解--Field--介绍-Toy模板网

这篇具有很好参考价值的文章主要介绍了es--基础--9.2--SpringBoot注解--Field--介绍。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

es–基础–9.2–SpringBoot注解–Field–介绍

内容

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@Documented
@Inherited
public @interface Field {
	@AliasFor("name")
	String value() default "";
	
	@AliasFor("value")
	String name() default "";
	
	# 自动检测属性的类型，可以根据实际情况自己设置
	FieldType type() default FieldType.Auto;
	
	# 是否建立索引
	boolean index() default true;
	
	# 时间类型的格式化
	DateFormat format() default DateFormat.none;
	
	String pattern() default "";
	
	# 默认情况下不存储原文
	boolean store() default false;
	
	boolean fielddata() default false;
	
	# 指定字段搜索时使用的分词器
	String searchAnalyzer() default "";
	
	# 指定字段搜索时使用的分词器
	String analyzer() default "";
	
	String normalizer() default "";
	
	# 如果某个字段需要被忽略
	String[] ignoreFields() default {};
	
	boolean includeInParent() default false;
	
	String[] copyTo() default {};
	
	int ignoreAbove() default -1;
	
	boolean coerce() default true;
	
	boolean docValues() default true;
	
	boolean ignoreMalformed() default false;
	
	IndexOptions indexOptions() default IndexOptions.none;
	
	boolean indexPhrases() default false;
	
	implemented as array to enable the empty default value
	
	IndexPrefixes[] indexPrefixes() default {};
	
	boolean norms() default true;
	
	String nullValue() default "";
	
	int positionIncrementGap() default -1;
	
	Similarity similarity() default Similarity.Default;
	
	TermVector termVector() default TermVector.none;
	
	double scalingFactor() default 1;
	
	int maxShingleSize() default -1;
	 
	
	boolean storeNullValue() default false;
	
	
	boolean positiveScoreImpact() default true;
	
	boolean enabled() default true;
	
	boolean eagerGlobalOrdinals() default false;
	
	NullValueType nullValueType() default NullValueType.String;

}

1、String value() default “”;

字段名称，是name的别名

2、String name() default “”;

字段名称

3、FieldType type() default FieldType.Auto;

字段类型
默认：自动检测字段的类型

4、boolean index() default true;

是否建立索引
false：
1. 不能查询
2. 不能得到返回

5、DateFormat format() default DateFormat.none;

时间类型的格式化

6、String pattern() default “”;111

7、boolean store() default false;

是否存储原文
false：字段内容存储到_source中
ture：字段内容存储到其他地方，不存储到_source中

7.1、field是怎么存储的

当你将一个field的store属性设置为true，这个会在lucene层面处理。lucene是倒排索引，可以执行快速的全文检索，返回符合检索条件的文档id列表。
在全文索引之外，lucene也提供了存储字段的值的特性，以支持提供id的查询(根据id得到原始信息)。

7.2、_source(store=false)

会存储每一个文档的完整信息
好处
1. 因为_source 是把所有字段保存为一份文档，命中后读取只需要一次 IO
坏处
1. 查询的时候，是返回整个文档，因为_source 是把所有字段保存为一份文档，如果文档内容很大，是非常占用带宽的，通常我们也不需要整个文档(可能只关心摘要)，因为可能就查询几个字段，而store=ture，就是来解决这个问题的

7.3、store=ture

在 _source 存储之外再为这个字段独立进行存储
使用场景
1. 针对内容比较多的字段
坏处
1. 从每一个stored field中获取值都需要一次磁盘io，如果想获取多个field的值，就需要多次磁盘io，但是，如果从_source中获取多个field的值，则只需要一次磁盘io，因为_source只是一个字段而已。所以在大多数情况下，从_source中获取是快速而高效的。
注意：
1. 将 store 设置为 yes，一般来说还应该在 _source 排除 exclude 掉这个字段，这时候索引的字段，不会保存在 _source 里了，会独立存储一份，查询时 _source 里也没有这个字段了，但是还是可以通过指定返回字段来获取，但是会有额外的 IO 开销。
  1. _source 的读取需要一次 IO
  2. field 字段的读取需要一次 IO

7.4、match 和高亮

store=ture：
1. 可以 match
2. 可以高亮
store=false，且_source 不存储：
1. 数据不会返回了
2. 数据不能高亮
3. 可以 match

8、boolean fielddata() default false;

是否支持聚合查询

8.1、doc_values

支持排序，聚合，脚本等需求，以面向列的方式存储，对于排序和聚合来说更高效
对于text字段，doc_values是不支持的。除非使用fielddata

8.2、fielddata

这是一种把text字段放到内存中来处理的方式，先直接从磁盘读取每个段的反向索引，然后通过反向索引，反转索引与文档的关系，最后将结果放到JVM堆内存中来处理。
由于fielddata的机制，会占用大量堆空间，因此可能会造成频繁的FullGC，导致用户遇到延迟、卡顿等现象，这也是为什么fielddata默认为不开启的原因。
替代方案：keyword

9、String searchAnalyzer() default “”;

查询时，先对要查询的text类型的输入做分词，再去倒排索引中搜索。

10、String analyzer() default “”;

插入文档时，将text类型的字段做分词然后插入倒排索引。

11、String normalizer() default “”;

normalizer：是keyword的一个属性，可以对 keyword 生成的单一Term 再做进一步的处理。简单来说，就是对字段的内容进行处理。

11.1、“normalizer”: “lowercase”

文档写入时，所有的 term 都会被做小写处理，也就是说字段内容都小写后，再存储
查询时，如果参数是这个字段，那么字段内容都小写后，再查询

12、String[] ignoreFields() default {};

某个字段需要被忽略
因为_source会存储每一个文档的完整信息，返回的时候会返回整个文档，使用ignoreFields，那么会忽略掉对应的字段。

13、boolean includeInParent() default false;

设置所有嵌套对象属性的include_in_parent值
true：在嵌套对象中的所有字段会被添加到父文档的作为标准字段
false：

13.1、举例

字段类型为nested类型时

"entity": [
    {
        "id": "1"  
        "name": "张三"
    },
    {
        "id": "2"
        "name": "李四"
    }
]

当字段类型为nested类型时，需要把entity字段的include_in_parent属性设置成true，例如：


"entity": {
    "type": "nested",
    "include_in_parent": true,    //默认为false
    "properties": {
        "id": {
            "type": "keyword"
        },
        "name": {
            "type": "text",
            "fields": {
                "completion": {
                    "type": "text",
                    "analyzer": "completion_analyzer"
                },
                "keyword": {
                    "type": "keyword"
                },
                "pinyin": {
                    "type": "text",
                    "analyzer": "full_pinyin_analyzer"
                }
            },
            "analyzer": "ik_max_word"
        }
    }
}

以下查询语句才会生效：

{
  "query": {
    "script": {
      "script": "doc['entity.id'].size() > 1"  //1代表的是数组长度
    }
  }
}

14、String[] copyTo() default {};

可以将多个字段的值复制到组字段中(F1)，然后可以将其作为单个字段(F1)进行查询。
F1：text类型
它是复制的字段值，而不是术语(由分析过程产生的)。
_source不会修改原始字段以显示复制的值。
可以将相同的值复制到多个字段中 “copy_to”: [ “field_1”, “field_2” ]

14.1、案例

PUT my_index
{
  "mappings": {
    "_doc": {
      "properties": {
        "first_name": {
          "type": "text",
          "copy_to": "full_name"
        },
        "last_name": {
          "type": "text",
          "copy_to": "full_name"
        },
        "full_name": {
          "type": "text"
        }
      }
    }
  }
}
 
PUT my_index/_doc/1
{
  "first_name": "John",
  "last_name": "Smith"
}

irst_name和last_name字段的值将复制到 full_name字段中。

该first_name和last_name领域仍可以分别查询了第一个名字和姓氏，但full_name现场可以查询两个姓和名。

GET my_index/_search
{
  "query": {
    "match": {
      "full_name": {
        "query": "John Smith",
        "operator": "and"
      }
    }
  }
}

15、int ignoreAbove() default -1;

设置字段值的最大长度
超出这个长度的字段将不会被索引，但是会存储。

16、boolean coerce() default true;

是否强制尝试清除脏值以适合字段的数据类型
true：尝试清除脏值
false：不清除脏值，那么请求的参数一定要符合字段类型的要求

16.1、介绍

数据并不总是干净的。根据它的生成方式，数字可能会在JSON正文中呈现为真正的JSON数字，例如5，但它也可能呈现为字符串，例如"5"。或者，应该是整数的数字可以替代地呈现为浮点，例如5.0，或甚至"5.0"。

改参数，就是设置请求的参数是否一定要符合字段类型的要求。

16.2、案例

PUT my_index
{
  "mappings": {
    "_doc": {
      "properties": {
        "number_one": {
          "type": "integer"
        },
        "number_two": {
          "type": "integer",
          "coerce": false
        }
      }
    }
  }
}
 
PUT my_index/_doc/1
{
  "number_one": "10"
}
 
PUT my_index/_doc/2
{
  "number_two": "10"
}

文档1，改请求能够执行
文档2，改请求能够报错，因为规定number_two的值必须为integer，而不是字符串。

17、boolean docValues() default true;

倒排索引可以提供全文检索能力，但是无法提供对排序和数据聚合的支持。doc_values 本质上是一个序列化的列式存储结构，适用于聚合(aggregations)、排序(Sorting)、脚本(scripts access to field)等操作。
默认情况下，ES几乎会为所有类型的字段存储doc_value，但是 text 或 text_annotated 等可分词字段不支持 doc values 。
如果不需要对某个字段进行排序或者聚合，则可以关闭该字段的doc_value存储。

https://blog.csdn.net/a745233700/article/details/117915118

18、boolean ignoreMalformed() default false;

是否忽略字段格式类型
false：不忽略，如果将错误的数据类型映射到字段中则会报错
true：忽略，当你对数据类型不太确定时，可以尝试配置这个属性为true。

18.1、案例

创建一个索引，number_one和number_two两个属性都是integer类型的，但是number_one配置了 “ignore_malformed”: true


PUT my-index-000001
{
  "mappings": {
    "properties": {
      "number_one": {
        "type": "integer",
        "ignore_malformed": true
      },
      "number_two": {
        "type": "integer"
      }
    }
  }
}

number_one添加一条字符类型的数据，能够添加成功。

PUT my-index-000001/_doc/1
{
  "text":       "Some text value",
  "number_one": "foo" 
}

number_two添加一条字符类型的数据，则提示数据类型异常。

PUT my-index-000001/_doc/2
{
  "text":       "Some text value",
  "number_two": "foo" 
}

19、IndexOptions indexOptions() default IndexOptions.none;

用于控制添加到倒排索引中的信息，服务于搜索和高亮等目的。

19.1、包括以下参数

docs：只有文档编号被索引。能够回答的问题只有此 term(词条)是否存在于此字段。
freqs：
1. 文档编号和term(词条)的频率会被索引。
2. term(词条)频率用于给搜索评分，重复出现的term(词条)评分将高于单个出现的term(词条)。
positions：
1. 文档编号、term frequencies(词条频率)和term(词条)位置(或顺序)将被索引。4
2. Position被用于 proximity queries (邻近查询)和phrase queries(短语查询)。
offsets：
1. 文档编号、term(词条)频率，位置，起始和结尾字符偏移量(用于映射该 term (词条)到原始字符串)将被索引。
2. Offset用于postings highlighter。
被分析器分析的字符串字段使用 **position **作为默认值，其他的字段使用 **docs **作为默认值。

20、boolean indexPhrases() default false;

主要将两个单词的组合索引到单独字段中，这样在进行精确的短语查询的时候会更有效。
text 字段具有index＿phrases选项，该选项索引2个，并且查询解析器会自动利用该选项来运行不带斜率的词组查询。如果您的用例涉及运行大量短语查询，则可以大大加快查询速度。
提升短语查询速度，但是要消耗更多磁盘空间

20.1、案例

20.1.1、创建索引

# index_phrases

PUT /my_index
{
  "mappings" : {
    "properties" : {
      "name" : {
        "type"          : "text",
        "index_phrases" : true,
        "fields" : {
          "normal" : {
            "type" : "text"
          }
        }
      }
    }
  }
}
 
# 插入
POST /my_index/_doc/1
{
  "name" : "this is a dog is dog is dog"
}

# 插入
POST /my_index/_doc/2
{
  "name" : "this is dog"
}

20.1.2、查询1

# 搜索, index_phrases 为 true
GET /my_index/_search
{
  "query" : {
    "match_phrase" : {
      "name" : "is dog"
    }
  }
}

结果

{
  "took" : 0,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 2,
      "relation" : "eq"
    },
    "max_score" : 0.23594555,
    "hits" : [
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 0.23594555,
        "_source" : {
          "name" : "this is dog"
        }
      },
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 0.21681483,
        "_source" : {
          "name" : "this is a dog is dog is dog"
        }
      }
    ]
  }
}

20.1.3、查询2

# 搜索, index_phrases 为 false
GET /my_index/_search
{
  "query" : {
    "match_phrase" : {
      "name.normal" : "is dog"
    }
  }
}

结果

{
  "took" : 0,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 2,
      "relation" : "eq"
    },
    "max_score" : 0.44793728,
    "hits" : [
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "2",
        "_score" : 0.44793728,
        "_source" : {
          "name" : "this is dog"
        }
      },
      {
        "_index" : "my_index",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 0.44455233,
        "_source" : {
          "name" : "this is a dog is dog is dog"
        }
      }
    ]
  }
}

21、NullValueType nullValueType() default NullValueType.String;

null值类型，有以下几个值

String
Integer
Long
Double

22、IndexPrefixes[] indexPrefixes() default {};

为字段值的前缀编制索引，以加快前缀搜索速度
min_chars：前缀最小长度，>0，默认2(包含)
max_chars：前缀最大长度，<20，默认5(包含)

PUT my_index
{
  "mappings": {
    "properties": {
      "full_name": {
        "type": "text",
        "index_prefixes": {
          "min_chars" : 1,
          "max_chars" : 10
        }
      }
    }
  }
}

23、boolean norms() default true;

是否禁用评分
1. false：禁用
2. true：不禁用
当计算得分的时候，是否需要把字段长度用作参数计算，尽管计算得分时把字段长度考虑在内可以提高得分的精确性，但这样会消耗大量的磁盘空间(每个文档的每个字段都会消耗一个字节，即使某些文档不包含这个字段)。因此，如果不需要计算字段的得分，你应该禁用该字段的norms
场景
1. 在过滤和聚合字段上应该禁用
只有type 为 “text” 的字段，才能设置 norms=true
只有type 为 “keyword” 类型的字段，才能设置 norms=false

PUT my_index/_mapping
{
  "properties": {
    "title": {
      "type": "text",
      "norms": false
    }
  }
}

24、String nullValue() default “”;

使用指定的值替换为null值，以便可以进行索引和搜索

25、int positionIncrementGap() default -1;

当该field类型是text，且value是一个数组的时候才会起作用，将在值之间添加"假gap"间隙，以防止大多数短语查询在值之间
正常情况下一个text输入field之前会进行analysis，一般会有ananlzyer分词，并且记录每个词的position，当一个filed的输入有多个values的时候，会填充虚假的gap，让不同的field之间的position加大。

25.1、案例

观察下面的analyze


# 插入数据
POST my_index/_analyze
{
  "analyzer": "standard",
  "text": ["want some","like bread"]
}




{
  "tokens" : [
    {
      "token" : "want",
      "start_offset" : 0,
      "end_offset" : 4,
      "type" : "<ALPHANUM>",
      "position" : 0
    },
    {
      "token" : "some",
      "start_offset" : 5,
      "end_offset" : 9,
      "type" : "<ALPHANUM>",
      "position" : 1
    },
    {
      "token" : "like",
      "start_offset" : 10,
      "end_offset" : 14,
      "type" : "<ALPHANUM>",
      "position" : 102
    },
    {
      "token" : "bread",
      "start_offset" : 15,
      "end_offset" : 20,
      "type" : "<ALPHANUM>",
      "position" : 103
    }
  ]
}

可以看到 like bread的position 一个是102，一个是103，这就说明中间加入了虚假的gap，因为中间的position实际上是没有值的。
这种操作主要是为了在进行phrase查询的时候出错，比如查询some like命中了该文档是不合理的

25.2、案例2

PUT my_index
{
  "mappings": {
    "properties": {
      "names": {
        "type": "text",
        "position_increment_gap": 0 
      }
    }
  }
}

PUT my_index/_doc/1
{
    "names": [ "John Abraham", "Lincoln Smith"]
}

GET my_index/_search
{
    "query": {
        "match_phrase": {
            "names": "Abraham Lincoln" 
        }
    }
}

该查询会将doc1召回，显然是不合理的

26、Similarity similarity() default Similarity.Default;

针对 text类型
为字段设置相似度计算模型
这个计算模型可以自定义，也可以使用es内置的
es内置的相似度打分模型有3个
1. BM25：es中默认的打分模型
2. classic：es早起版本的打分模型，也是经典的打分模型
3. boolean：只能判断是否命中，得分score就是query boost

PUT my_index
{
  "mappings": {
    "properties": {
      "default_field": { 
        "type": "text"
      },
      "boolean_sim_field": {
        "type": "text",
        "similarity": "boolean" 
      }
    }
  }
}

27、TermVector termVector() default TermVector.none;

针对 text类型
term向量是针对字段数据进行了analysis处理后的产生的term的组合
存储字段的词矢量(Term vectors)信息。包括：词、位置、偏移量、有效载荷
场景
1. 一般情况下没有什么用，只是在快速高亮显示上又一些用处。
缺点
1. 会使字段在索引中的存储翻倍，因为需要一个额外的list terms去维护。

27.1、term 包含了下面的内容

一个terms的list
每个term中的position(位置)
每个term在原始文档中的offset(偏移量)
payload(有效载荷)信息

27.2、term_vector 的设置

no: No term vectors are stored。 (default) 这个是默认值
yes: Just the terms in the field are stored。
with_positions: Terms and positions are stored。
with_offsets: Terms and character offsets are stored。
with_positions_offsets: Terms，positions，and character offsets are stored。
with_positions_payloads: Terms，positions，and payloads are stored。
with_positions_offsets_payloads: Terms，positions，offsets and payloads are stored。

27.3、term_vector 的设置

当我们使用term vectors API的时候可以查看一个文档中field的vector

27.3.1、创建索引和插入数据

# 创建索引
PUT my_index
{
  "mappings": {
    "properties": {
      "text": {
        "type":        "text",
        "term_vector": "with_positions_offsets"
      },
      "number":{
        "type": "text"
      }
    }
  }
}

# 插入数据
PUT my_index/_doc/1?refresh
{
  "text": "Quick brown fox",
  "number":"want app and want banana"
}

27.3.2、使用terms vectors api 查看field包含的terms

GET my_index/_termvectors/1?fields=number,text


{
  "_index" : "my_index",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 1,
  "found" : true,
  "took" : 0,
  "term_vectors" : {
    "text" : {
      "field_statistics" : {
        "sum_doc_freq" : 3,
        "doc_count" : 1,
        "sum_ttf" : 3
      },
      "terms" : {
        "brown" : {
          "term_freq" : 1,
          "tokens" : [ { "position" : 1, "start_offset" : 6, "end_offset" : 11}]
        },
        "fox" : {
          "term_freq" : 1,
          "tokens" : [ { "position" : 2, "start_offset" : 12, "end_offset" : 15}]
        },
        "quick" : {
          "term_freq" : 1,
          "tokens" : [ { "position" : 0, "start_offset" : 0, "end_offset" : 5}]
        }
      }
    },
    "number" : {
      "field_statistics" : {
        "sum_doc_freq" : 4,
        "doc_count" : 1,
        "sum_ttf" : 5
      },
      "terms" : {
        "and" : {
          "term_freq" : 1,
          "tokens" : [ { "position" : 2, "start_offset" : 9, "end_offset" : 12}]
        },
        "app" : {
          "term_freq" : 1,
          "tokens" : [ { "position" : 1, "start_offset" : 5, "end_offset" : 8}]
        },
        "banana" : {
          "term_freq" : 1,
          "tokens" : [ { "position" : 4, "start_offset" : 18, "end_offset" : 24}]
        },
        "want" : {
          "term_freq" : 2,
          "tokens" : [ { "position" : 0, "start_offset" : 0, "end_offset" : 4}, 
	             { "position" : 3, "start_offset" : 13, "end_offset" : 17}]
        }
      }
    }
  }
}

以上，可以看到文档的term vector信息，
number字段没有设置保存term_vector，在使用api的时候依然能够查到，这是因为terms vector api的原理导致的，如果没有的话他会自己从index中进行计算得到数据

27.3.3、假如直接使用

GET my_index/_termvectors/1

这个只会获取默认已经存储的term vectors，那么就不会返回number的term vectors了。

使用

GET my_index/_termvectors/1?fields=number,text

会触发强制计算term vectors。

28、double scalingFactor() default 1;

使用缩放因子将浮点数据存储到整数
scalingFactor 由 long 数据类型来支持。long 数据类型在 Lucene 里可以被更加有效地压缩，从而节省存储的空间。
举例：
1. 定义 scalingFactor 为 100。这样我们的数据，比如 1.99 刚好可以在乘以 100 变为 199，从而成为一个整型数。

29、int maxShingleSize() default -1;

分词的深度

29.1、案例

如果你有文本 “foo bar baz” 并再次使用 in_shingle_size 为 2 且 max_shingle_size 为 3，则你将生成以下 token：

foo, foo bar, foo bar baz, bar, bar baz, baz

29.2、使用

PUT my_index
{
  "settings": {
    "analysis": {
      "analyzer": {
        "shingle": {
          "type": "custom",
          "tokenizer": "standard",
          "filter": [
            "shingle-filter"
          ]
        }
      },
      "filter": {
        "shingle-filter": {
          "type": "shingle",
          "min_shingle_size": 2,
          "max_shingle_size": 3,
          "output_unigrams": false
        }
      }
    }
  }
}

30、boolean storeNullValue() default false;

是否能存储null文章来源地址https://www.toymoban.com/news/detail-781613.html

31、boolean positiveScoreImpact() default true;

和排名功能查询相关
涉及字段类型
1. rank_feature
2. rank_features

32、boolean enabled() default true;

是否创建倒排索引
1. false：
  1. 不建立索引，仍然可以检索并在_source元数据中展示，谨慎使用，该状态无法修改。
  2. 不能被搜索
  3. 不能存储
2. true：建立索引，可以对其进行获取，但是不会以任何方式对它的内容建立索引
可以对字段操作，也可以对索引操作
1. 对索引操作，这样的话index的所有字段都是没有indexed的
使用场景
1. 只能应用于顶级映射和object类型下

32.1、举例1

PUT my_index
{
  "mappings": {
    "properties": {
      "user_id": {
        "type":  "keyword"
      },
      "last_updated": {
        "type": "date"
      },
      "session_data": { 
        "type": "object",
        "enabled": false
      }
    }
  }
}

PUT my_index/_doc/session_1
{
  "user_id": "kimchy",
  "session_data": { 
    "arbitrary_object": {
      "some_array": [ "foo", "bar", { "baz": 2 } ]
    }
  },
  "last_updated": "2015-12-06T18:20:22"
}

PUT my_index/_doc/session_2
{
  "user_id": "jpountz",
  "session_data": "none", 
  "last_updated": "2015-12-06T18:22:13"
}


GET my_index
返回
{
  "my_index" : {
    "aliases" : { },
    "mappings" : {
      "properties" : {
        "last_updated" : {
          "type" : "date"
        },
        "session_data" : {
          "type" : "object",
          "enabled" : false
        },
        "user_id" : {
          "type" : "keyword"
        }
      }
    }
}

禁用了session_data字段。
任何任意数据都可以传递到session_data字段，因为它将被完全忽略。会存在_source当中，不能被搜索，对应的mapping文件也不会有dynamic field加入
session_data还将忽略非JSON对象的值。

33、boolean eagerGlobalOrdinals() default false;

eagerGlobalOrdinals：是否渴望(eager)全局序号(Ordinals)
1. 本质：是否启用聚合性能优化，启用的话，能提升高基数聚合性能。
2. 适用场景：
  1. 高基数聚合
  2. 高基数聚合场景中的高基数含义：一个字段包含很大比例的唯一值。
global ordinals 表示全局序号，是一种数据结构，应用场景如下：
1. 基于 keyword，ip 等字段的分桶聚合，包含：terms聚合、composite聚合等。
2. 基于 text 字段的分桶聚合(前提条件是：fielddata 开启)。
3. 基于父子文档 Join 类型的 has_child 查询和父聚合。
global ordinals 使用一个数值代表字段中的字符串值，然后为每一个数值分配一个 bucket(分桶)。
启用 eager_global_ordinals 时，会在刷新(refresh)分片时构建全局序号。这将构建全局序号的成本从搜索阶段转移到了数据索引化(写入)阶段。

PUT /my‐index 
{ 
"mappings": {
 "properties": {
  "tags": { 
 	"type": "keyword",
  	"eager_global_ordinals": true
  } 
 } 
}

到了这里，关于es--基础--9.2--SpringBoot注解--Field--介绍的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

es--基础--9.2--SpringBoot注解--Field--介绍