ElasticSearch 动态映射和静态映射，以及四种字段类型

红太狼 2022-12-25 01:50 258阅读 0赞

### 文章目录 ###

*   *  1.ElasticSearch 映射
     *   *  1.1 映射分类
         *  1.2 类型推断
     *  2.ElasticSearch 字段类型
     *   *  2.1 核心类型
         *   *  2.1.1 字符串类型
             *  2.1.2 数字类型
             *  2.1.3 日期类型
             *  2.1.4 布尔类型（boolean）
             *  2.1.5 二进制类型（binary）
             *  2.1.6 范围类型
         *  2.2 复合类型
         *   *  2.2.1 数组类型
             *  2.2.2 对象类型（object）
             *  2.2.3 嵌套类型（nested）
         *  2.3 地理类型
         *   *  2.3.1 geo\_point
             *  2.3.2 geo\_shape
         *  2.4 特殊类型
         *   *  2.4.1 IP
             *  2.4.2 token\_count

ElasticSearch 系列教程我们前面已经连着发了三篇了，今天第四篇，我们来聊一聊 Es 中的动态映射、静态映射以及四种不同的字段类型。

本文是松哥所录视频教程的一个笔记，笔记简明扼要，完整内容小伙伴们可以参考视频，视频下载链接：https://pan.baidu.com/s/1oKiV7FRkppZnMAmRGNNrGg 提取码: p3sx

![883c8d52543907615646bb1db156b845.png][]

## 1.ElasticSearch 映射 ##

映射就是 Mapping，它用来定义一个文档以及文档所包含的字段该如何被存储和索引。所以，它其实有点类似于关系型数据库中表的定义。

### 1.1 映射分类 ###

**动态映射**

顾名思义，就是自动创建出来的映射。es 根据存入的文档，自动分析出来文档中字段的类型以及存储方式，这种就是动态映射。

举一个简单例子，新建一个索引，然后查看索引信息：

![image-20201106201219878][]

在创建好的索引信息中，可以看到，mappings 为空，这个 mappings 中保存的就是映射信息。

现在我们向索引中添加一个文档，如下：

PUT blog/_doc/1
    {
      "title":"1111",
      "date":"2020-11-11"
    }

文档添加成功后，就会自动生成 Mappings：

![image-20201106201516427][]

可以看到，date 字段的类型为 date，title 的类型有两个，text 和 keyword。

默认情况下，文档中如果新增了字段，mappings 中也会自动新增进来。

有的时候，如果希望新增字段时，能够抛出异常来提醒开发者，这个可以通过 mappings 中 dynamic 属性来配置。

dynamic 属性有三种取值：

*  true，默认即此。自动添加新字段。
 *  false，忽略新字段。
 *  strict，严格模式，发现新字段会抛出异常。

具体配置方式如下，创建索引时指定 mappings（这其实就是静态映射）：

PUT blog
    {
      "mappings": {
        "dynamic":"strict",
        "properties": {
          "title":{
            "type": "text"
          },
          "age":{
            "type":"long"
          }
        }
      }
    }

然后向 blog 中索引中添加数据：

PUT blog/_doc/2
    {
      "title":"1111",
      "date":"2020-11-11",
      "age":99
    }

在添加的文档中，多出了一个 date 字段，而该字段没有预定义，所以这个添加操作就回报错：

{
      "error" : {
        "root_cause" : [
          {
            "type" : "strict_dynamic_mapping_exception",
            "reason" : "mapping set to strict, dynamic introduction of [date] within [_doc] is not allowed"
          }
        ],
        "type" : "strict_dynamic_mapping_exception",
        "reason" : "mapping set to strict, dynamic introduction of [date] within [_doc] is not allowed"
      },
      "status" : 400
    }

动态映射还有一个日期检测的问题。

例如新建一个索引，然后添加一个含有日期的文档，如下：

PUT blog/_doc/1
    {
      "remark":"2020-11-11"
    }

添加成功后，remark 字段会被推断是一个日期类型。

![image-20201106203240406][]

此时，remark 字段就无法存储其他类型了。

PUT blog/_doc/1
    {
      "remark":"javaboy"
    }

此时报错如下：

{
      "error" : {
        "root_cause" : [
          {
            "type" : "mapper_parsing_exception",
            "reason" : "failed to parse field [remark] of type [date] in document with id '1'. Preview of field's value: 'javaboy'"
          }
        ],
        "type" : "mapper_parsing_exception",
        "reason" : "failed to parse field [remark] of type [date] in document with id '1'. Preview of field's value: 'javaboy'",
        "caused_by" : {
          "type" : "illegal_argument_exception",
          "reason" : "failed to parse date field [javaboy] with format [strict_date_optional_time||epoch_millis]",
          "caused_by" : {
            "type" : "date_time_parse_exception",
            "reason" : "Failed to parse with all enclosed parsers"
          }
        }
      },
      "status" : 400
    }

要解决这个问题，可以使用静态映射，即在索引定义时，将 remark 指定为 text 类型。也可以关闭日期检测。

PUT blog
    {
      "mappings": {
        "date_detection": false
      }
    }

此时日期类型就回当成文本来处理。

**静态映射**

略。

### 1.2 类型推断 ###

es 中动态映射类型推断方式如下：

<table> 
 <thead> 
  <tr> 
   <th>JSON 中的数据</th> 
   <th>自动推断出来的数据类型</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>null</td> 
   <td>没有字段被添加</td> 
  </tr> 
  <tr> 
   <td>true/false</td> 
   <td>boolean</td> 
  </tr> 
  <tr> 
   <td>浮点数字</td> 
   <td>float</td> 
  </tr> 
  <tr> 
   <td>数字</td> 
   <td>long</td> 
  </tr> 
  <tr> 
   <td>JSON 对象</td> 
   <td>object</td> 
  </tr> 
  <tr> 
   <td>数组</td> 
   <td>数组中的第一个非空值来决定</td> 
  </tr> 
  <tr> 
   <td>string</td> 
   <td>text/keyword/date/double/long 都有可能</td> 
  </tr> 
 </tbody> 
</table>

## 2.ElasticSearch 字段类型 ##

### 2.1 核心类型 ###

#### 2.1.1 字符串类型 ####

*  string：这是一个已经过期的字符串类型。在 es5 之前，用这个来描述字符串，现在的话，它已经被 text 和 keyword 替代了。
 *  text：如果一个字段是要被全文检索的，比如说博客内容、新闻内容、产品描述，那么可以使用 text。用了 text 之后，字段内容会被分析，在生成倒排索引之前，字符串会被分词器分成一个个词项。text 类型的字段不用于排序，很少用于聚合。这种字符串也被称为 analyzed 字段。
 *  keyword：这种类型适用于结构化的字段，例如标签、email 地址、手机号码等等，这种类型的字段可以用作过滤、排序、聚合等。这种字符串也称之为 not-analyzed 字段。

#### 2.1.2 数字类型 ####

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>取值范围</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>long</td> 
   <td>-2<sup>63到2</sup>63-1</td> 
  </tr> 
  <tr> 
   <td>integer</td> 
   <td>-2<sup>31到2</sup>31-1</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>-2<sup>15到2</sup>15-1</td> 
  </tr> 
  <tr> 
   <td>byte</td> 
   <td>-2<sup>7到2</sup>7-1</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>64 位的双精度 IEEE754 浮点类型</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>32 位的双精度 IEEE754 浮点类型</td> 
  </tr> 
  <tr> 
   <td>half_float</td> 
   <td>16 位的双精度 IEEE754 浮点类型</td> 
  </tr> 
  <tr> 
   <td>scaled_float</td> 
   <td>缩放类型的浮点类型</td> 
  </tr> 
 </tbody> 
</table>

*  在满足需求的情况下，优先使用范围小的字段。字段长度越短，索引和搜索的效率越高。
 *  浮点数，优先考虑使用 scaled\_float。

scaled\_float 举例：

PUT product
    {
      "mappings": {
        "properties": {
          "name":{
            "type": "text"
          },
          "price":{
            "type": "scaled_float",
            "scaling_factor": 100
          }
        }
      }
    }

#### 2.1.3 日期类型 ####

由于 JSON 中没有日期类型，所以 es 中的日期类型形式就比较多样：

*  2020-11-11 或者 2020-11-11 11:11:11
 *  一个从 1970.1.1 零点到现在的一个秒数或者毫秒数。

es 内部将时间转为 UTC，然后将时间按照 millseconds-since-the-epoch 的长整型来存储。

自定义日期类型：

PUT product
    {
      "mappings": {
        "properties": {
          "date":{
            "type": "date"
          }
        }
      }
    }

这个能够解析出来的时间格式比较多。

PUT product/_doc/1
    {
      "date":"2020-11-11"
    }
    
    PUT product/_doc/2
    {
      "date":"2020-11-11T11:11:11Z"
    }
    
    
    PUT product/_doc/3
    {
      "date":"1604672099958"
    }

上面三个文档中的日期都可以被解析，内部存储的是毫秒计时的长整型数。

#### 2.1.4 布尔类型（boolean） ####

JSON 中的 “true”、“false”、true、false 都可以。

#### 2.1.5 二进制类型（binary） ####

二进制接受的是 base64 编码的字符串，默认不存储，也不可搜索。

#### 2.1.6 范围类型 ####

*  integer\_range
 *  float\_range
 *  long\_range
 *  double\_range
 *  date\_range
 *  ip\_range

定义的时候，指定范围类型即可：

PUT product
    {
      "mappings": {
        "properties": {
          "date":{
            "type": "date"
          },
          "price":{
            "type":"float_range"
          }
        }
      }
    }

插入文档的时候，需要指定范围的界限：

指定范围的时，可以使用 gt、gte、lt、lte。

### 2.2 复合类型 ###

#### 2.2.1 数组类型 ####

es 中没有专门的数组类型。默认情况下，任何字段都可以有一个或者多个值。需要注意的是，数组中的元素必须是同一种类型。

添加数组是，数组中的第一个元素决定了整个数组的类型。

#### 2.2.2 对象类型（object） ####

由于 JSON 本身具有层级关系，所以文档包含内部对象。内部对象中，还可以再包含内部对象。

PUT product/_doc/2
    {
      "date":"2020-11-11T11:11:11Z",
      "ext_info":{
        "address":"China"
      }
    }

#### 2.2.3 嵌套类型（nested） ####

nested 是 object 中的一个特例。

如果使用 object 类型，假如有如下一个文档：

{
      "user":[
        {
          "first":"Zhang",
          "last":"san"
        },
        {
          "first":"Li",
          "last":"si"
        }
        ]
    }

由于 Lucene 没有内部对象的概念，所以 es 会将对象层次扁平化，将一个对象转为字段名和值构成的简单列表。即上面的文档，最终存储形式如下：

{
    "user.first":["Zhang","Li"],
    "user.last":["san","si"]
    }

扁平化之后，用户名之间的关系没了。这样会导致如果搜索 Zhang si 这个人，会搜索到。

此时可以 nested 类型来解决问题，nested 对象类型可以保持数组中每个对象的独立性。nested 类型将数组中的每一饿对象作为独立隐藏文档来索引，这样每一个嵌套对象都可以独立被索引。

{
    {
    "user.first":"Zhang",
    "user.last":"san"
    },{
    "user.first":"Li",
    "user.last":"si"
    }
    }

**优点**

文档存储在一起，读取性能高。

**缺点**

更新父或者子文档时需要更新更个文档。

### 2.3 地理类型 ###

使用场景：

*  查找某一个范围内的地理位置
 *  通过地理位置或者相对中心点的距离来聚合文档
 *  把距离整个到文档的评分中
 *  通过距离对文档进行排序

#### 2.3.1 geo\_point ####

geo\_point 就是一个坐标点，定义方式如下：

PUT people
    {
      "mappings": {
        "properties": {
          "location":{
            "type": "geo_point"
          }
        }
      }
    }

创建时指定字段类型，存储的时候，有四种方式：

PUT people/_doc/1
    {
      "location":{
        "lat": 34.27,
        "lon": 108.94
      }
    }
    
    PUT people/_doc/2
    {
      "location":"34.27,108.94"
    }
    
    PUT people/_doc/3
    {
      "location":"uzbrgzfxuzup"
    }
    
    PUT people/_doc/4
    {
      "location":[108.94,34.27]
    }

注意，使用数组描述，先经度后纬度。

地址位置转 geo\_hash：http://www.csxgame.top/\#/

#### 2.3.2 geo\_shape ####

<table> 
 <thead> 
  <tr> 
   <th>GeoJSON</th> 
   <th>ElasticSearch</th> 
   <th>备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Point</td> 
   <td>point</td> 
   <td>一个由经纬度描述的点</td> 
  </tr> 
  <tr> 
   <td>LineString</td> 
   <td>linestring</td> 
   <td>一个任意的线条，由两个以上的点组成</td> 
  </tr> 
  <tr> 
   <td>Polygon</td> 
   <td>polygon</td> 
   <td>一个封闭多边形</td> 
  </tr> 
  <tr> 
   <td>MultiPoint</td> 
   <td>multipoint</td> 
   <td>一组不连续的点</td> 
  </tr> 
  <tr> 
   <td>MultiLineString</td> 
   <td>multilinestring</td> 
   <td>多条不关联的线</td> 
  </tr> 
  <tr> 
   <td>MultiPolygon</td> 
   <td>multipolygon</td> 
   <td>多个多边形</td> 
  </tr> 
  <tr> 
   <td>GeometryCollection</td> 
   <td>geometrycollection</td> 
   <td>几何对象的集合</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>circle</td> 
   <td>一个圆形</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>envelope</td> 
   <td>通过左上角和右下角两个点确定的矩形</td> 
  </tr> 
 </tbody> 
</table>

指定 geo\_shape 类型：

PUT people
    {
      "mappings": {
        "properties": {
          "location":{
            "type": "geo_shape"
          }
        }
      }
    }

添加文档时需要指定具体的类型：

PUT people/_doc/1
    {
      "location":{
        "type":"point",
        "coordinates": [108.94,34.27]
      }
    }

如果是 linestring，如下：

PUT people/_doc/2
    {
      "location":{
        "type":"linestring",
        "coordinates": [[108.94,34.27],[100,33]]
      }
    }

### 2.4 特殊类型 ###

#### 2.4.1 IP ####

存储 IP 地址，类型是 ip：

PUT blog
    {
      "mappings": {
        "properties": {
          "address":{
            "type": "ip"
          }
        }
      }
    }

添加文档：

PUT blog/_doc/1
    {
      "address":"192.168.91.1"
    }

搜索文档：

GET blog/_search
    {
      "query": {
        "term": {
          "address": "192.168.0.0/16"
        }
      }
    }

#### 2.4.2 token\_count ####

用于统计字符串分词后的词项个数。

PUT blog
    {
      "mappings": {
        "properties": {
          "title":{
            "type": "text",
            "fields": {
              "length":{
                "type":"token_count",
                "analyzer":"standard"
              }
            }
          }
        }
      }
    }

相当于新增了 title.length 字段用来统计分词后词项的个数。

添加文档：

PUT blog/_doc/1
    {
      "title":"zhang san"
    }

可以通过 token\_count 去查询：

GET blog/_search
    {
      "query": {
        "term": {
          "title.length": 2
        }
      }
    }

最后，松哥还搜集了 50+ 个项目需求文档，想做个项目练练手的小伙伴不妨看看哦～

![e219fd4cd10e143d33b27336e29bed0a.png][]  
![b8fc793dbdc8fda1f3954b002764502f.png][]  
![d59d5cc147ae46000f08cb1ffdda204e.png][]

需求文档地址：[https://github.com/lenve/javadoc][https_github.com_lenve_javadoc]

[883c8d52543907615646bb1db156b845.png]: /images/20221120/cf1fa71886c14a63b0e634b5eb940506.png
[image-20201106201219878]: /images/20221120/61606e071fac4f3e8cb84cd8cfd56485.png
[image-20201106201516427]: /images/20221120/d7628d3c009f479d80955b7369dc71ae.png
[image-20201106203240406]: /images/20221120/61fb567f569146eda591f6c0188682b0.png
[e219fd4cd10e143d33b27336e29bed0a.png]: /images/20221120/15feb850ce8045f0b2633f601a7e9912.png
[b8fc793dbdc8fda1f3954b002764502f.png]: /images/20221120/61a6c8575d7e4fa89b8fcd1bd085f629.png
[d59d5cc147ae46000f08cb1ffdda204e.png]: https://img-blog.csdnimg.cn/img_convert/d59d5cc147ae46000f08cb1ffdda204e.png
[https_github.com_lenve_javadoc]: https://github.com/lenve/javadoc