ElasticSearch 学习（一）——安装配置，基本概念与操作

喜欢ヅ旅行 2022-11-05 00:43 162阅读 0赞

# Elastic Search 学习 #

## 安装与环境配置 ##

#### 安装包下载 ####

安装环境为macOS，直接去官网进行下载解压安装，但是下载很慢，是外网。

官网下载网址：[https://www.elastic.co/cn/downloads/elasticsearch][https_www.elastic.co_cn_downloads_elasticsearch]

也可以直接使用brew安装，网上都有教程。

#### 可视化插件选择 ####

直接去chrome商店下载Elastic Search head插件，是一款管理ES的可视化插件。

[https://chrome.google.com/webstore/detail/elasticsearch-head/ffmkiejjmecolpfloofpjologoblkegm][https_chrome.google.com_webstore_detail_elasticsearch-head_ffmkiejjmecolpfloofpjologoblkegm]

## 相关概念 ##

与MySQL进行对比，两者对应的概念如下

<table> 
 <thead> 
  <tr> 
   <th>Relational DB</th> 
   <th>DataBase</th> 
   <th>Tables</th> 
   <th>Rows</th> 
   <th>Columns</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Elastic Search</td> 
   <td>Indices</td> 
   <td>Types</td> 
   <td>Documents</td> 
   <td>Fields</td> 
  </tr> 
 </tbody> 
</table>

#### 索引 index ####

具有相似特征的文档集合。通常会为具有一组共同字段的文档定义一个类型。例如，运营一个博客平台，将所有数据存储到一个索引中，在这个索引中，用户数据是一个类型，博客文章是一个类型，评论数据是一个类型。

#### 字段 field ####

相当于数据表字段，对文档数据根据不同属性分类标识。

#### 映射 mapping ####

对处理数据的方式和规则方面做一些限制。

## 索引基本操作 ##

### 创建一个索引 ###

PUT /索引名/[类型名]/文档id	//类型名会被弃用，默认为_doc
    { 
    	"name":"zhangsan",
    	"age":18
    }

创建完索引之后，数据也成功添加，也可以在head中进行数据预览。

此时发现 name age等字段没有设置类型，可以指定字段的类型。

PUT /test1	 //此时只有索引，没有后续参数，
    
    { 
        "mappings":{ 
            "properties":{ 
                "name":{ 
                    "type":"text"
                },
                "age":{ 
                    "type":"long"
                },
                "birthday":{ 
                    "type":"date"
                }
            }
        }
    }

创建了具体的数据规则。

### 获取索引信息 ###

通过get请求获取具体的信息，如果文档字段没有指定，ES会默认配置字段类型

GET /test1

**通过 GET \_cat/ 命令，可以获得ES中的很多信息**

### 修改索引信息 ###

*  直接重新PUT一遍
 *  使用POST命令
 *      POST /索引名称/类型名称/文档id/_update

### 删除索引 ###

DELETE /索引名称  	//直接删除索引库
    DELETE /索引名称/类型名称/文档id		//删除索引中的某个文档

## 文档操作 ##

### 添加数据 ###

PUT /test/user/1
    
    { 
      "name":"zhangsan",
    	"age":18,
      "tag":["高","富","帅"]
    }

### 查询数据 ###

GET /test/user/1

### 更新数据 ###

PUT /test/user/1	//缺失的字段会被置空
    
    { 
      "name":"wangwu",
      "age":18,
      "tag":["白","富","美"]
    }
    
    //更推荐POST
    POST /test/user/1/_update
    
    { 
      "name":"wangwu",
      "age":18,
      "tag":["白","富","美"]
    }

### 搜索搜索操作 ###

##### 简单条件查询（所有查询都用GET操作） #####

GET /test/user/_search?q=name:zhangsan //精确匹配查找name为zhangsan的

查询结果

{ 
        "took": 2,
        "timed_out": false,
        "_shards": { 
            "total": 1,
            "successful": 1,
            "skipped": 0,
            "failed": 0
        },
        "hits": { 															//hits对象Java中的Hits对象
            "total": { 
                "value": 1,
                "relation": "eq"
            },
            "max_score": 0.9808291,		//最大的得分值
            "hits": [
                { 															//查询出来的具体文档，都可以通过遍历得到
                    "_index": "test",
                    "_type": "user",
                    "_id": "2",
                    "_score": 0.9808291,
                    "_source": { 
                        "name": "zhangsan",
                        "age": 18,
                        "tag": [
                            "高",
                            "富",
                            "丑"
                        ]
                    }
                }
            ]
        }
    }

查询结果中的score代表查询结果的匹配程度高低

##### 复杂查询（排序，分页，高亮，模糊查询，精准查询） #####

GET /test/user/_search
    
    { 
      "query":{ 
          "match":{ 
              "name":"%zhangsan%"
          }
      }
    }

###### 指定查询结果展示字段 ######

{ 
      "query":{ 
          "match":{ 
              "name":"%zhangsan%"
          }
      }
      "_source":["name","age"]		//只需要name和age
    }

###### 按字段排序展示查询结果，并且进行分页 ######

{ 
      "query":{ 
          "match":{ 
              "name":"张"	//按张进行匹配，张三，张四，张三丰这种分词后都带张，都可以匹配到
          }
        },
        "sort":[	  //sort表示排序，asc按升序查询
            { 
                "age":{ 
                  "order":"asc"
                }
            }
        ],
        "from":0,	//从第几条数据开始
        "size":2	//每页展示几条数据
    }

###### 布尔值查询，可以进行多条件查询 ######

{ 
      "query":{ 
          "bool":{ 
              "must":[
                  { 
                      "match":{ 
                          "name":"张"
                      }
                  },
                  { 
                      "match":{ 
                          "age":18
                      }
                  }
              ]
          }
        }
    }

*  must (and)，所有条件都要符合，where name = “张” and age=18
 *  should (or)，或操作，where name = “张” or age = 18
 *  must\_not (not)，否操作，不等于

###### 过滤 ######

{ 
      "query":{ 
          "bool":{ 
              "should":[
                  { 
                      "match":{ 
                          "name":"张"
                      }
                  },
                  { 
                      "match":{ 
                          "age":18
                      }
                }
              ],
              "filter":{ 			//采用filer关键字，与should，must等同级
                  "range":{ 
                      "age":{ 
                          "gt":10		//可以进行多个 gt lt lte gte 等同时过滤
                      }
                  }
                }
            }
        }
    }

*  gt大于
 *  gte大于等于
 *  lt小于
 *  lte小于等于

###### 匹配多个条件 ######

{ 
      "query":{ 
          "match":{ 
              "tag":"穷 丑"		//直接在搜索关键字字段里用空格隔开，含有 穷 丑 的都能匹配
          }
        }
    }

###### 查询结果 ######

{ 
        "took": 5,
        "timed_out": false,
        "_shards": { 
            "total": 1,
            "successful": 1,
            "skipped": 0,
            "failed": 0
        },
        "hits": { 
            "total": { 
                "value": 7,		//总共有7条数据符合，也可以按照匹配分值进行筛选
                "relation": "eq"
            },
            "max_score": 1.6063561,		//最匹配的分数为 1.61，按分数高低排列
            "hits": [
                { 
                    "_index": "test",
                    "_type": "user",
                    "_id": "8",
                    "_score": 1.6063561,	//可以看到包含了 穷 丑 两个
                    "_source": { 
                        "name": "张四",
                        "age": 21,
                        "tag": [
                            "挨",
                            "穷",
                            "丑"
                        ]
                    }
                },
                { 
                    "_index": "test",
                    "_type": "user",
                    "_id": "1",
                    "_score": 1.2809337,	//只包含穷，分数降低
                    "_source": { 
                        "name": "lisi",
                        "age": 23,
                        "tag": [
                            "矮",
                            "穷",
                            "帅"
                        ]
                    }
                },
                { 
                    "_index": "test",
                    "_type": "user",
                    "_id": "2",
                    "_score": 0.3254224,
                    "_source": { 
                        "name": "zhangsan",
                        "age": 18,
                        "tag": [
                            "高",
                            "富",
                            "丑"
                        ]
                    }
                },
                { 
                    "_index": "test",
                    "_type": "user",
                    "_id": "4",
                    "_score": 0.3254224,
                    "_source": { 
                        "name": "张三",
                        "age": 18,
                        "tag": [
                            "高",
                            "富",
                            "丑"
                        ]
                    }
                },
                { 
                    "_index": "test",
                    "_type": "user",
                    "_id": "5",
                    "_score": 0.3254224,
                    "_source": { 
                        "name": "李四",
                        "age": 18,
                        "tag": [
                            "高",
                            "富",
                            "丑"
                        ]
                    }
                },
                { 
                    "_index": "test",
                    "_type": "user",
                    "_id": "6",
                    "_score": 0.3254224,
                    "_source": { 
                        "name": "张三丰",
                        "age": 26,
                        "tag": [
                            "高",
                            "富",
                            "丑"
                        ]
                    }
                },
                { 
                    "_index": "test",
                    "_type": "user",
                    "_id": "7",
                    "_score": 0.3254224,
                    "_source": { 
                        "name": "王五",
                        "age": 21,
                        "tag": [
                            "高",
                            "富",
                            "丑"
                        ]
                    }
                }
            ]
        }
    }

###### 精确查询 ######

term 查询是直接通过倒排索引进行精确查找

match 会使用**分词器解析**

**两个类型 text 和 keyword**

text可以被分词器解析；而keyword不能被分词器解析，只能作为整体。以下为示例

//先创建一个testdb作为测试索引
    PUT /testdb 
    
    { 
      "mappings":{ 
        "properties":{ 
          "name":{ 
            "type":"text"
          },
          "desc":{ 
            "type":"keyword"
          }
        }
      }
    }
    
    PUT /testdb/_doc/1			//插入两条数据
    
    { 
      "name":"爱新觉罗张三 name",
    	"desc":"爱新觉罗张三 desc"
    }
    
    PUT /testdb/_doc/2			
    
    { 
      "name":"爱新觉罗张三 name",
    	"desc":"爱新觉罗张三 desc2"
    }

可以先看一下分析器对于 keyword 和 standard的分析区别

GET /_analyze
    
    //body:
    { 
        "analyzer":"keyword",
        "text":"爱新觉罗张三 name"
    }
    
    //结果：
    { 
        "tokens": [
            { 
                "token": "爱新觉罗张三 name",
                "start_offset": 0,
                "end_offset": 11,
                "type": "word",
                "position": 0
            }
        ]
    }
    
    //body:
    { 
        "analyzer":"standard",
        "text":"爱新觉罗张三 name"
    }
    
    //结果：
    { 
        "tokens": [
            { 
                "token": "爱",
                "start_offset": 0,
                "end_offset": 1,
                "type": "<IDEOGRAPHIC>",
                "position": 0
            },
            { 
                "token": "新",
                "start_offset": 1,
                "end_offset": 2,
                "type": "<IDEOGRAPHIC>",
                "position": 1
            },
            { 
                "token": "觉",
                "start_offset": 2,
                "end_offset": 3,
                "type": "<IDEOGRAPHIC>",
                "position": 2
            },
            { 
                "token": "罗",
                "start_offset": 3,
                "end_offset": 4,
                "type": "<IDEOGRAPHIC>",
                "position": 3
            },
            { 
                "token": "张",
                "start_offset": 4,
                "end_offset": 5,
                "type": "<IDEOGRAPHIC>",
                "position": 4
            },
            { 
                "token": "三",
                "start_offset": 5,
                "end_offset": 6,
                "type": "<IDEOGRAPHIC>",
                "position": 5
            },
            { 
                "token": "name",
                "start_offset": 7,
                "end_offset": 11,
                "type": "<ALPHANUM>",
                "position": 6
            }
        ]
    }

*  keyword 不会被分词器分析，会将其当作整体

那么我们对上面添加的 两条数据进行搜索实验：

{ 
      "name":"爱新觉罗张三 name",
    	"desc":"爱新觉罗张三 desc"
    }		
    { 
      "name":"爱新觉罗张三 name",
    	"desc":"爱新觉罗张三 desc2"
    }
    //其中 name 是 text ，desc 是 keyword
    
    GET /_search
    { 
        "query":{ 
            "term":{ 
                "name":"爱"
            }
        }
    }
    
    //结果：
    { 
        "took": 1,
        "timed_out": false,
        "_shards": { 
            "total": 1,
            "successful": 1,
            "skipped": 0,
            "failed": 0
        },
        "hits": { 
            "total": { 
                "value": 2,
                "relation": "eq"
            },
            "max_score": 0.18232156,
            "hits": [
                { 
                    "_index": "testdb",
                    "_type": "_doc",
                    "_id": "1",
                    "_score": 0.18232156,
                    "_source": { 
                        "name": "爱新觉罗张三 name",
                        "desc": "爱新觉罗张三 desc"
                    }
                },
                { 
                    "_index": "testdb",
                    "_type": "_doc",
                    "_id": "2",
                    "_score": 0.18232156,
                    "_source": { 
                        "name": "爱新觉罗张三 name",
                        "desc": "爱新觉罗张三 desc2"
                    }
                }
            ]
        }
    }
    //name是text格式，“爱新觉罗张三 name” 被分词解析，所以查询任一个中文或英文单词 name 都有结果返回
    
    GET /_search
    { 
        "query":{ 
            "term":{ 
                "desc":"爱"
            }
        }
    }
    
    //结果
    { 
        "took": 1,
        "timed_out": false,
        "_shards": { 
            "total": 1,
            "successful": 1,
            "skipped": 0,
            "failed": 0
        },
        "hits": { 
            "total": { 
                "value": 0,
                "relation": "eq"
            },
            "max_score": null,
            "hits": []
        }
    }
    //desc是keyword类型，爱新觉罗张三 desc 没有被分词，所以查单个汉字无结果，只有查整体才行，如下：
    
    { 
        "query":{ 
            "term":{ 
                "desc":"爱新觉罗张三 desc"
            }
        }
    }

###### 多个值匹配的精确查询 ######

先放入两条数据

PUT /testdb/_doc/3
    { 
        "t1":"22",
        "t2":"2020-4-6"
    }
    
    PUT /testdb/_doc/4
    { 
        "t1":"33",
        "t2":"2020-4-7"
    }
    
    //进行多个值精确匹配查询
    
    GET /testdb/_search
    
    // 查询 t1 为 22 或 33的
    { 
        "query":{ 
            "bool":{ 
                "should":[
                    { 
                        "term":
                        { 
                            "t1":22
                        }
                    },
                    { 
                        "term":
                        { 
                            "t1":33
                        }
                    }
                ]
            }
        }
    }

###### 高亮关键字 ######

直接查看实现高亮的方法，实际上是为需要高亮的文本添加html标签以修饰

GET /test/user/_search
    
    { 
      "query":{ 
          "match":{ 
              "name":"张"
          }
        },
        "highlight":{ 	//配置高亮的一些参数 
            "pre_tags":"<p class='key' style='color:red'>" ,	//高亮标签前缀，默认 em 
            "post_tags":"</p>" ,	//高亮标签后缀 
            "fields":{ 		//高亮的区域 
                "name":{ }
            }
        }
    }

综上，ES可以做到：

*  匹配，按照条件匹配，精确匹配，区间范围匹配，匹配字段过滤
 *  多条件查询，高亮查询

下一章将ES集成到SpringBoot中去。

[https_www.elastic.co_cn_downloads_elasticsearch]: https://www.elastic.co/cn/downloads/elasticsearch
[https_chrome.google.com_webstore_detail_elasticsearch-head_ffmkiejjmecolpfloofpjologoblkegm]: https://chrome.google.com/webstore/detail/elasticsearch-head/ffmkiejjmecolpfloofpjologoblkegm