ElasticSearch基本操作_es中9100是什么-CSDN博客

本文链接：https://blog.csdn.net/weixin_43423306/article/details/107528327

一、ElasticSearch概述

Elaticsearch，简称为es， es是一个开源的高扩展的分布式全文检索引擎，它可以近乎实时的存储、检
索数据；本身扩展性很好，可以扩展到上百台服务器，处理PB级别（大数据时代）的数据。es也使用
Java开发并使用Lucene作为其核心来实现所有索引和搜索的功能，但是它的目的是通过简单的RESTful
API来隐藏Lucene的复杂性，从而让全文搜索变得简单。

环境搭建地址: ElasticSearch环境搭建

二、测试环境搭建

1.访问测试ElasticSearch

2.访问测试Kibana

搭建Elasticsearch-head

3.1. 通过docker pull拉取镜像

docker pull mobz/elasticsearch-head:5

3.2. 启动elasticsearch-head

docker run -p 9100:9100 mobz/elasticsearch-head:5

3.3. 浏览器访问IP：9100

3.4. 链接elasticsearch
iamge
3.5. 注意事项

连接 ES 服务发现连接不上存在跨域问题！
- 因为项目是在9100端口而es在9200端口端口不同存在跨域问题

解决方案

打开 es的目录下的 config/elasticsearch.yml

http.cors.enabled: true  # 开启跨域
http.cors.allow-origin: "*"  # 允许所有源进行访问

3.6. 重启es服务器

连接成功
搭建完成

docker run --restart=no -p 9100:9100 mobz/elasticsearch-head:5

三、ES核心概念

1、索引

2、字段类型（mapping）

3、文档（documents）

elasticsearch是面向文档，关系行数据库 和 elasticsearch 客观的对比！一切都是JSON！

Relational DB	Elasticsearch
数据库(database)	索引(indices)
表(tables)	types
行(rows)	documents
字段(columns)	fields

elasticsearch(集群)中可以包含多个索引(数据库)，每个索引中可以包含多个类型(表)，每个类型下又包
含多个文档(行)，每个文档中又包含多个字段(列)。

物理设计：
elasticsearch 在后台把每个索引划分成多个分片，每分分片可以在集群中的不同服务器间迁移
一个人就是一个集群！默认的集群名称就是 elaticsearh

逻辑设计：
一个索引类型中，包含多个文档，比如说文档1，文档2。

当我们索引一篇文档时，可以通过这样的一各
顺序找到它: 索引 ▷ 类型 ▷ 文档ID ，通过这个组合我们就能索引到某个具体的文档。注意:ID不必是整
数，实际上它是个字符串。

文档就是我们的一条条数据

之前说elasticsearch是面向文档的，那么就意味着索引和搜索数据的最小单位是文档，elasticsearch中，文档有几个重要属性 :

自我包含，一篇文档同时包含字段和对应的值，也就是同时包含key:value
可以是层次型的，一个文档中包含自文档，复杂的逻辑实体就是这么来的！ {就是一个json对象！fastjson进行自动转换}

灵活的结构，文档不依赖预先定义的模式，我们知道关系型数据库中，要提前定义字段才能使用，在elasticsearch中，对于字段是非常灵活的，有时候，我们可以忽略该字段，或者动态的添加一个新的字段。

尽管我们可以随意的新增或者忽略某个字段，但是，每个字段的类型非常重要，比如一个年龄字段类
型，可以是字符串也可以是整形。因为elasticsearch会保存字段和类型之间的映射及其他的设置。这种映射具体到每个映射的每种类型，这也是为什么在elasticsearch中，类型有时候也称为映射类型。

类型是文档的逻辑容器，就像关系型数据库一样，表格是行的容器。类型中对于字段的定义称为映射，比如name映射为字符串类型。

我们说文档是无模式的，它们不需要拥有映射中所定义的所有字段，比如新增一个字段，那么elasticsearch是怎么做的呢?elasticsearch会自动的将新字段加入映射，但是这个字段的不确定它是什么类型，elasticsearch就开始猜，如果这个值是18，那么elasticsearch会认为它是整形。

但是elasticsearch也可能猜不对，所以最安全的方式就是提前定义好所需要的映射，这点跟关系型数据库殊途同归了，先定义好字段，然后再使用，别整什么幺蛾子。

就是数据库！
索引是映射类型的容器，elasticsearch中的索引是一个非常大的文档集合。索引存储了映射类型的字段和其他设置。然后它们被存储到了各个分片上了。我们来研究下分片是如何工作的。

物理设计：节点和分片如何工作
一个集群至少有一个节点，而一个节点就是一个*elasricsearch进程，节点可以有多个索引默认

的，如果你创建索引，那么索引将会有个5个分片 ( primary shard,又称主分片 ) 构成的，每一个主分片会有一个副本 ( replica shard,又称复制分片 )

上图是一个有3个节点的集群，可以看到主分片和对应的复制分片都不会在同一个节点内，这样有利于某个节点挂掉了，数据也不至于丢失。实际上，一个分片是一个Lucene索引，一个包含倒排索引的文件目录，倒排索引的结构使得elasticsearch在不扫描全部文档的情况下，就能告诉你哪些文档包含特定的关键字。不过，等等，倒排索引是什么鬼?

elasticsearch使用的是一种称为倒排索引的结构，采用 Lucene倒排索作为底层。这种结构适用于快速的全文搜索，一个索引由文档中所有不重复的列表构成，对于每一个词，都有一个包含它的文档列表。例如，现在有两个文档，每个文档包含如下内容：

为了创建倒排索引，我们首先要将每个文档拆分成独立的词(或称为词条或者tokens)，然后创建一个包含所有不重复的词条的排序列表，然后列出每个词条出现在哪个文档 :

Study  every  day,  good  good  up  to  forever	#  文档1包含的内容
To  forever,  study  every  day,  good  good  up  #  文档2包含的内容

term	doc_1	doc_2
Study	√	×
To	x	×
every	√	√
forever	√	√
day	√	√
study	×	√
good	√	√
every	√	√
to	√	×
up	√	√
to	√	×
forever	√	√
total	2	1

现在，我们试图搜索 to forever，只需要查看包含每个词条的文档 score
两个文档都匹配，但是第一个文档比第二个匹配程度更高。如果没有别的条件，现在，这两个包含关键字的文档都将返回。
再来看一个示例，比如我们通过博客标签来搜索博客文章。那么倒排索引列表就是这样的一个结构 :

如果要搜索含有 python标签的文章，那相对于查找所有原始数据而言，查找倒排索引后的数据将会快的多。只需要查看标签这一栏，然后获取相关的文章ID即可。完全过滤掉无关的所有数据，提高效率！

elasticsearch的索引和Lucene的索引对比
在 elasticsearch中，索引（库）这个词被频繁使用，这就是术语的使用。在 elasticsearch中，索引被分为多个分片，每份分片是一个 Lucene的索引。所以一个 elasticsearch索引是由多个 Lucene索引组成的。别问为什么，谁让 elasticsearch使用 Lucene作为底层呢! 如无特指，说起索引都是指 elasticsearch的索引。

接下来的一切操作都在 kibana中 Dev Tools下的 Console里完成。基础操作！

四、IK分词器插件

1.创建文件夹

# 递归创建ik文件夹
mkdir /usr/local/docker/ELK/Kibana/ik
# 移动到ik目录
cd /usr/local/docker/ELK/Kibana/ik

2.下载镜像包

wget https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.4.2/elasticsearch-analysis-ik-7.4.2.zip

3.给文件权限

chmod -R 777 ik

4.重启Elasticsearch即可

docker restart elasticsearch

5.使用Kibana
其中 ik_smart 为最少切分

ik_max_word为最细粒度划分！穷尽词库的可能！字典！

发现问题：师文远被拆开了！这种自己需要的词，需要自己加到我们的分词器的字典中！

6.ik分词器
config目录文件解析

xxx.dic  # 为ik内置的词库  打开即为一个一个的词
IKAnalyzer.cfg.xml  # 这个是 ik 分词器的配置文件

自定义词库

在config目录里新建你的 xxx.pic 文件
打开你新建的文件 直接写入需要的词语
ik词典

打开 IKAnalyzer.cfg.xml 配置你自己的词典这里与 ssm的配置文件类似当然你也可以配置多个！！

7.重启ElasticSearch容器查看运行结果

GET _analyze
{
  "analyzer": "ik_smart",  # 最少切分
  "text": "Redis中国网站" #要切分的文本
}

GET _analyze
{
  "analyzer": "ik_max_word",  # 最细粒度切分  穷尽词库的可能！字典！
  "text": "Redis中国网站"  # 要切分的文本
}

通过以上测试结果可以看到不管是哪种切分方式都会根据你的词库来进行切分

五、Rest风格说明

method	url地址	描述
PUT	localhost:9200/索引名称/类型名称/文档id	创建文档（指定文档id）
POST	localhost:9200/索引名称/类型名称	创建文档（随机文档id）
POST	localhost:9200/索引名称/类型名称/文档id/_update	修改文档
DELETE	localhost:9200/索引名称/类型名称/文档id	删除文档
GET	localhost:9200/索引名称/类型名称/文档id	查询文档通过文档id
POST	localhost:9200/索引名称/类型名称/_search	查询所有数据

六、关于索引的基本操作

1.创建一个索引！

PUT /swy_test/user/1   (/索引名/类型/文档id)
{
	"name":"swy",
	"age":21
} # 如果这个索引不存在则会自动创建该索引

完成了自动增加了索引！数据也成功的添加了，这就是我说大家在初期可以把它当做数据库学习的原因

那么name这个字段用不用指定类型呢。毕竟我们关系型数据库是需要指定类型的啊 !

字符串类型

text 、 keyword
数值类型

long, integer, short, byte, double, float, half_float, scaled_float
日期类型

date
te布尔值类型

boolean
二进制类型

binary
等等…

2.指定字段的类型

PUT /swy   # /索引名/类型/文档id
{
  "mappings": {  # 字段映射
    "properties": {  # 存放所有字段的属性
      "name":{  # 字段1
        "type": "text"  # 类型
      }, 
      "age":{  # 字段 2
        "type":"integer"  # 类型
      },
      "birthday":{  # 字段3
        "type": "date"  # 类型
      }
    }
  }
}

6.1获取es所有的索引信息

通过命令elasticsearch索引情况！通过get _cat/ 可以获得es的当前的很多信息！

6.2删除索引

DELETE /swy_test2  # 通过 DELETE请求来删除某个索引

七、文档操作（重点）

7.1创建文档

PUT /swy/usr/1
{
  "name":"swy",
	"age":21,
	"desc": "一顿操作猛如虎，一看工资2500"
}

如果创建索引的时候没有指定类型的话默认类型为 _doc
第一次创建文档的时候 result状态为 created

7.2获取数据

GET /swy/usr/1

7.3 修改数据

7.3.1 PUT方式修改

PUT /swy/usr/1
{
  "name":"swy",
	"age":21,
	"desc": "一顿操作猛如虎，一看工资2500",
	"js": "Javak开发工程师"
}

7.3.2 POST方式修改

POST /swy/usr/1
{
  "name":"swy",
	"age":21,
	"desc": "一顿操作猛如虎，一看工资2500",
	"js": "Javak开发工程师",
	"school" : "河南财经政法大学"
}

八、搜索

一、简单的搜索

GET /swy/_search?q=name:swy

二、复杂查询

2.1 mathc 查询

match query 知道分词器的存在他会根据分词器进行拆分

如果查询的数据没有在分词器中配置的话那么就会进行精确查询
分词器中配置了该词的结果

分词器中没有配置该词的结果

GET /yufire/_doc/_search
{
  "query":{
    "match":{
      "name":"中国中央电视"
    }
  }
}

2.2结果过滤

在 query节点后边加上_source 输入过滤字段即可

GET swy/usr/_search
{
  "query": {
    "match": {
      "name": "swy"
    }
  }
  , "_source": ["name","age","desc","js","school"]
}

2.3 排序

在 query节点后边添加 sort 节点

GET /swy/usr/_search
{
  "query":{
    "match":{
      "name":"中央"
    }
  },
  "_source":["age"],
  "sort":{
    "age":{
      "order":"asc"
    }
  }
}

2.4 分页查询

分页查询与mysql中类似只需要两个参数即可
from : 对应MySQL中的 limit 第一个参数
size : 对应MySQL中的 limit 第二个参数
limit from,size

GET /swy/usr/_search
{
  "query":{
    "match":{
      "name":"中央"
    }
  },
  "_source":["age"],
  "sort":{
    "age":{
      "order":"asc"
    }
  },
  "from":0,
  "size":2
}
# limit from,size

2.5 布尔值查询 and

多条件查询
must （and），所有的条件都要符合 where name=xxx1 and age= xxx

GET /swy/usr/_search
{
  "query": {
    "bool": {
      "must": [  # 存放条件的数组
        {  # 一个个的条件对象
          "match": {
            "name": "中央电视台"
          }
        },
        {  # 一个个的条件对象
          "match": {
            "age": 17
          }
        }
      ]
    }
  }
}

2.6 布尔值查询 or

should 关键字就等于mysql中的 or
should (or) where name=xxx or age=xxx.

GET 
{
  "query": {
    "bool": {
      "should": [
        {
          "match": {
            "name": "中央电视台"
          }
        },
        {
          "match": {
            "age": 17
          }
        }
      ]
    }
  }
}

2.7 布尔值查询 not

must_not 就相当于mysql中的 not

GET /swy/usr/_search
{
  "query": {
    "bool": {
      "must_not": [
        {
          "match": {
            "age": 17
          }
        }
      ]
    }
  }
}

2.8 过滤器 filter

可以使用 filter进行数据的过滤
gt 大于
gte 大于等于
lt 小于
lte 小于等于！

GET /swy/usr/_search
{
  "query": {
    "bool": {
      "must_not": [
        {
          "match": {
            "age": 17
          }
        }
      ],
      "filter": {
        "range": {
          "age": {
            "gte": 1,
            "lte": 3
          }
        }
      }
    }
  }
}

2.9 匹配数组

如果文档中的数据有数组的话可以直接用match关键字进行匹配

GET /swy/usr/_search
{
  "query":{
    "match":{
      "tags":"唱 跳 rap"
    }
  }
}