如何使用Elasticsearch中提供的RESTFul风格api?相信你在这里可以找到答案

骑猪看日落 2023-07-24 09:16 15阅读 0赞

# 前言: #

本篇会以小案例需求的方式带你学习Elasticsearch中基于RESTFulApi操作。手敲几遍，想不会也难。加油~

对了,这里使用的是Kibana和head进行的管理,如果没有接触,推荐看下面的博客,写的挺清楚。

*  干货：
    
     *  [入门Elasticsearch，里面包含了Kibana的安装~~][Elasticsearch_Kibana]
     *  [Elasticsearch中文分词器(elasticsearch-analysis-ik),下面案例中需求需要使用][Elasticsearch_elasticsearch-analysis-ik]
     *  [Elasticsearch中head服务详解][Elasticsearch_head]

### 文章目录 ###

*  前言:
 *  基本概念
 *  1. 索引管理
 *   *  1.1 创建索引
     *  1.2 查询索引
     *  1.3 删除索引
 *  2. 映射操作
 *   *  2.1 创建映射
     *  2.2 查看映射
 *  3. 数据操作
 *   *  3.1 添加数据,无id
     *  3.1 添加或更新数据,有id
     *  3.1 删除数据
 *  4. 查询操作
 *   *  4.1 通过id查询
     *  4.2 查询所有
     *  4.3 关键字查询
     *  4.4 复合查询-must
     *  4.5 复合查询-should
     *  4.6 精准查询-term
     *  4.7 范围查询-range
     *  4.8 排序-sort
     *  4.9 分页-from+size
 *  总结
 *   *  我们这篇共学了些什么呢?来一起捋一捋吧!

# 基本概念 #

Elasticsearch也是基于Lucene的全文检索库，本质也是存储数据，很多概念与MySQL类似的。

<table> 
 <thead> 
  <tr> 
   <th>概念</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>索引(indices)</td> 
   <td>Databases数据库</td> 
  </tr> 
  <tr> 
   <td>类型(type)</td> 
   <td>Table数据库</td> 
  </tr> 
  <tr> 
   <td>文档(Document)</td> 
   <td>Row行</td> 
  </tr> 
  <tr> 
   <td>字段(Field)</td> 
   <td>Columns</td> 
  </tr> 
 </tbody> 
</table>

*  索引库（indices）：indices是index的复数，代表许多的索引
 *  类型（type）：类型是模拟mysql中的table概念，一个索引库下可以有不同类型的索引，比如商品索引，订单索引，其数据格式不同。不过这会导致索引库混乱，因此未来版本中会移除这个概念。
 *  文档（document）：存入索引库原始的数据。比如每一条商品信息，就是一个文档。
 *  字段（field）：文档中的属性。
 *  映射配置（mappings）：字段的数据类型、属性、是否索引、是否存储等特性。

# 1. 索引管理 #

## 1.1 创建索引 ##

Elastic中索引相当于sql数据库中的数据库
    实例:
    PUT 索引名
    {}

![format_png][]  
![format_png 1][]

## 1.2 查询索引 ##

GET 索引名

![format_png 2][]

## 1.3 删除索引 ##

DELETE 索引名

![format_png 3][]

# 2. 映射操作 #

删除完成后记得再创建回来,因为还要使用

## 2.1 创建映射 ##

类型相当于sql数据库中的表

PUT 索引名/_mapping/类型
    {
      "properties": {
        "字段":{
          "参数名": "参数值"
        }
      }
    }
    
    解释:
    参数名: type,表示的是概参数的类型
    参数值:
      核心类型：
        字符串: text（可分词）、keyword（不可分词）
        整数：integer,long,short,byte
        浮点：double,float,half_float,scaled_float
        日期：date
        逻辑：boolean
      复合类型：
        数组：array
        对象：object
        嵌套：nested
      地理类型：
        地理坐标：geo_point
        地理地图：geo_shape
      特殊类型：
        IP：ip
        范围：completion
        令牌计数：token_count
        附件：attachment
        抽取：percolator
    
    关于参数类型的解释，这个博客感觉写的不错，分享给你们：https://www.jianshu.com/p/01f489c46c38

*  实例:

#创建映射
    PUT refapi/_mapping/book
    {
      "properties": {
        "title":{
          "type": "text",
          "analyzer": "ik_max_word"
        },
        "price":{
          "type": ""
        },
        "images":{
          "type": "keyword",
          "index": true
        }
      }
    }

![format_png 4][]

## 2.2 查看映射 ##

*  语法:`GET 索引号/_mapping`
 *  实例:`GET refapi/_mapping`

![format_png 5][]

# 3. 数据操作 #

## 3.1 添加数据,无id ##

*  语法:

POST 索引名/类型名
    {
      "属性":"值",
      "属性2":"值2"
    }

*  实例:

#添加数据,无id
    POST refapi/book
    {  
      "title":"女神养成计划II",
      "price":"128.5",
      "images":"1.png"
    }
    POST refapi/book
    {  
      "title":"Java核心技术",
      "price":"128.5",
      "images":"1.png"
    }
    POST refapi/book
    {  
      "title":"Java编程思想",
      "price":"128.5",
      "images":"1.png"
    }
    POST refapi/book
    {  
      "title":"PHP编程思想",
      "price":"128.5",
      "images":"1.png"
    }

![format_png 6][]

## 3.1 添加或更新数据,有id ##

*  语法: 如果id存在将更新, 如果不存在, 将添加

PUT 索引名/类型/id
    {
      "属性":"值",
      "属性2:"值2
    }

*  实例:

#添加或更新数据：有id
    PUT refapi/book/b001
    {
      "title":"女神养成计划III",
      "price":"138.5",
      "images":"3.png"
    }
    PUT refapi/book/b002
    {
      "title":"坏蛋是怎么炼成的",
      "price":"66.66",
      "images":"4.png"
    }

## 3.1 删除数据 ##

*  语法:`DELETE 索引名/类型/id`
 *  实例:`DELETE refapi/book/b002`

![format_png 7][]

# 4. 查询操作 #

## 4.1 通过id查询 ##

*  语法1:通过id查询所有字段

GET 索引/类型/id
    
    类似于sql中的(select * from book where id = ?)

*  实例1:

GET refapi/book/b001

![format_png 8][]

*  语法2:通过id查询部分字段

GET 索引/类型/id?_source=字段,字段2
    
    类似于sql中的(select title,price from book where id = ?)

*  实例2:

GET refapi/book/b001?_source=title,price

![format_png 9][]

## 4.2 查询所有 ##

*  语法1: 查询所有索引库

#查询所有索引库
    GET _search
    {
      "query": {
        "match_all": {}
      }
    }

![format_png 10][]

*  语法2: 查询指定索引库

#查询指定索引库
    GET 索引库/_search
    {
      "query": {
        "match_all": {}
      }
    }

*  实例2:

#查询指定索引库
    GET refapi/_search
    {
      "query": {
        "match_all": {}
      }
    }

![format_png 11][]

*  语法3:

#查询指定索引库 中部分列数据
    GET 索引库/_search
    {
      "query": {
        "match_all": {}
      },
      "_source": ["字段1","字段2",....]
    }

*  实例3:

#查询指定索引库 中部分列数据
    GET refapi/_search
    {
      "query": {
        "match_all": {}
      },
      "_source": ["title","price"]
    }

![format_png 12][]

## 4.3 关键字查询 ##

*  使用match处理条件
 *  语法:

GET 索引库/_search
    {
      "query": {
        "match": {
          "字段": "值"
        }
      }
    }

*  需求: 查询title为 “Java编程思想”
 *  实例:

GET refapi/_search
    {
      "query": {
        "match": {
          "title": "Java编程思想"
        }
      }
    }

![format_png 13][]

## 4.4 复合查询-must ##

相当于是and(交集)

*  语法:
    
     *  使用bool进行多条件拼凑
     *  采用 must、must\_not进行数据过滤
        
         *  must：需要留下来的数据
         *  must\_not：不需要留下的数据

#采用多条件进行查询，查询title为 “Java编程思想”
    GET 索引库/_search
    {
      "query": {
        "bool": {
          "must": [
            {
              关键字查询
            }
          ]
        }
      }
    }

*  实例1: 采用多条件进行查询, 查询title为"Java编程思想"的

#采用多条件进行查询，查询title为 “Java编程思想”
    GET refapi/_search
    {
      "query": {
        "bool": {
          "must": [
            {
              "match": {
                "title": "Java编程思想"
              }
            }
          ]
        }
      }
    }

![format_png 14][]

*  实例2: 采用多条件进行查询,查询title为"Java编程思想"的,不含"PHP"的

#采用多条件进行查询,查询title为"Java编程思想"的,不含"PHP"的
    GET refapi/_search
    {
      "query": {
        "bool": {
          "must": [
            {
              "match": {
                "title": "Java编程思想"
              }
            }
          ],
          "must_not": [
            {
              "match": {
                "title": "PHP"
              }
            }
          ]
        }
      }
    }

![format_png 15][]

## 4.5 复合查询-should ##

相当于是or(并集)

*  语法:

#复合查询-should
    # 查询"PHP编程思想" ，以及"女神养成记"相关数据
    GET 索引库/_search
    {
      "query": {
        "bool": {
          "should": [
            {
              关键字查询
            },
            {
              关键字查询
            },
            ......
          ]
        }
      }
    }

*  需求: 查询“PHP编程思想” ，以及 女神养成记 相关数据
 *  实例:

#复合查询-should
    # 查询"PHP编程思想" ，以及"女神养成记"相关数据
    GET refapi/_search
    {
      "query": {
        "bool": {
          "should": [
            {
              "match": {
                "title": "PHP编程思想"
              }
            },
            {
              "match": {
                "title": "女神养成记"
              }
            }
          ]
        }
      }
    }

![format_png 16][]

## 4.6 精准查询-term ##

*  语法:

#查询价格为138.5 的信息
    GET 索引库/_search
    {
      "query": {
        "term": {
          "字段": {
            "value": "值"
          }
        }
      }
    }

*  需求: 查询价格为138.5 的信息
 *  实例:

#查询价格为138.5 的信息
    GET refapi/_search
    {
      "query": {
        "term": {
          "price": {
            "value": "138.5"
          }
        }
      }
    }

![format_png 17][]

## 4.7 范围查询-range ##

*  语法:

#范围查询-range
    GET 索引库/_search
    {
      "query": {
        "range": {
          "字段": {
            "gte": "大于等于",
            "lte": "小于等于",
            "gt": "大于",
            "lt": "小于"
          }
        }
      }
    }

*  需求: 查询价格在130 - 140 之间的数据
 *  实例:

#范围查询-range
    #查询价格在10 - 100 之间的数据
    GET refapi/_search
    {
      "query": {
        "range": {
          "price": {
            "gte": 130,
            "lte": 140
          }
        }
      }
    }

![format_png 18][]

## 4.8 排序-sort ##

*  语法:

GET 索引库/_search
    {
      "query": {
        "match_all": {}
      },
      "sort": [
        {
          "字段": {
            "order": "排序方式(desc/asc)"
          }
        }
      ]
    }

*  需求: 按照价格排序
 *  实例:

#按照价格排序
    GET refapi/_search
    {
      "query": {
        "match_all": {}
      },
      "sort": [
        {
          "price": {
            "order": "desc"
          }
        }
      ]
    }

![format_png 19][]

## 4.9 分页-from+size ##

*  语法:

GET 索引库/_search
    {
      "query": {
        "match_all": {}
      },
      "from": 0,
      "size": 2
    }

*  实例:

#分页-from+size
    GET refapi/_search
    {
      "query": {
        "match_all": {}
      },
      "from": 0,
      "size": 2
    }

![format_png 20][]

# 总结 #

## 我们这篇共学了些什么呢?来一起捋一捋吧! ##

*  1.索引的操作

创建：PUT 索引库
    查询：GET 索引库
    删除：DELETE 索引库

*  2.映射操作

创建映射：PUT 索引库/_mapping/类型
    查看映射：GET 索引库/类型

*  3.数据操作

添加: 无id,  有id只需要在类型后面跟/id即可
    POST 索引库/类型
    {
      "属性":"值"
    }
    删除: 无id,  有id只需要在类型后面跟/id即可
    DELETE 索引库/类型

*  4.查询操作

- 通过id查询:
    GET 索引库/类型/id
    GET 索引库/类型/id?_source=字段1,字段2

- 查询所有:
    GET 索引库/_search
    {
      "query":{
        "match_all":{}
      }
    }

- 关键字查询: match
    GET 索引库/_search
    {
      "query":{
        "match":{
          "字段":"值"
        }
      }
    }

- 复合查询: must(交集and)、should(并集or)
      使用bool进行多条件拼凑
        采用 must、must_not进行数据过滤
          must：需要留下来的数据
          must_not：不需要留下的数据

- 精准查询: term
    GET czxy/_search
    {
      "query": {
        "term": {
          "字段": {
            "value": "值"
          }
        }
      }
    }

- 范围查询: range
    GET 索引库/_search
    {
      "query": {
        "range": {
          "字段": {
            gt : "大于",
            lt : "小于",
            gte : "大于或等于",
            lte : "小于或等于"
          }
        }
      }
    }

- 排序: sort
    GET 索引库/_search
    {
      "query": {
        "match_all": {}
      },
      "sort": [
        {
          "字段": {
            "order": "排序方式(desc:降序/asc:升序)"
          }
        }
      ]
    }

- 分页: from+size
    from: 从第几个索引开始(从0开始)
    size:从from索引向后数几(size)个进行查询
    
    GET refapi/_search
    {
      "query": {
        "match_all": {}
      },
      "from": 0,
      "size": 2
    }

*  今天的学习就到这里了,不知道你有没有收获到一些知识呢? (\*￣︶￣)

[Elasticsearch_Kibana]: https://blog.csdn.net/weixin_44356673/article/details/105361415
[Elasticsearch_elasticsearch-analysis-ik]: https://blog.csdn.net/weixin_44356673/article/details/105361474
[Elasticsearch_head]: https://blog.csdn.net/weixin_44356673/article/details/105361493
[format_png]: /images/20230528/93b24bebde21457aaae52f37c473ce62.png
[format_png 1]: /images/20230528/1539a71ddcd544c982bbebc765982a4f.png
[format_png 2]: /images/20230528/086d47297c6843f2a9bbd39fcf64c662.png
[format_png 3]: /images/20230528/534657540ec14ff5875377877292c140.png
[format_png 4]: /images/20230528/140554214d7b45c9a526b9a3a85e658c.png
[format_png 5]: /images/20230528/8f7eeddf718c4a238a7b984e5cbd84e7.png
[format_png 6]: /images/20230528/68703d94b720458d863f9349fef3fce0.png
[format_png 7]: /images/20230528/a5c0cb762e2a40ccab6b20c77d16f4a9.png
[format_png 8]: /images/20230528/06c5e3bd0d8e4226a297f5be63822365.png
[format_png 9]: /images/20230528/c1d4ce9b25dc403083d9912f0ee6479c.png
[format_png 10]: /images/20230528/2a08321bc82241fdada203f3626d3edc.png
[format_png 11]: /images/20230528/970bda7fb05248b2b5654143a2f297ff.png
[format_png 12]: /images/20230528/a64cb670ff8241b1ac46ae59f72d560d.png
[format_png 13]: /images/20230528/c47cbf4b8dfe456caf890a2bb22a1c8b.png
[format_png 14]: /images/20230528/ee420c466b0149b7954556a41f387fab.png
[format_png 15]: /images/20230528/f42f464688414d55b52abc86deb893cd.png
[format_png 16]: /images/20230528/64de08e095014cd0867f08307fc75ea8.png
[format_png 17]: /images/20230528/858a7c3fc1734c91b5f7c9fce59a9bb0.png
[format_png 18]: /images/20230528/691caf59a043452f9e21c09c514d7ace.png
[format_png 19]: /images/20230528/9613c9bb6d774b64890a61ad8dc13800.png
[format_png 20]: /images/20230528/f2dcfc4768fb45e6950d4aa89665a71a.png