分布式项目的学而思6:elasticsearch的安装,使用(_cat,保存/查询文档,bulk批量操作,检索,DSL领域特定语言)

本文链接：https://blog.csdn.net/qq_43416157/article/details/116789009

elasticsearch

安装

下载

docker pull elasticsearch:7.4.2
docker pull kibana:7.4.2
版本要统一

配置启动

# 将docker里的目录挂载到linux的/mydata目录中
# 修改/mydata就可以改掉docker里的
mkdir -p /mydata/elasticsearch/config
mkdir -p /mydata/elasticsearch/data

# es可以被远程任何机器访问
echo "http.host: 0.0.0.0" >/mydata/elasticsearch/config/elasticsearch.yml

# 递归更改权限，es需要访问
chmod -R 777 /mydata/elasticsearch/

# 9200是用户交互端口 9300是集群心跳端口
# -e指定是单阶段运行
# -e指定占用的内存大小，生产时可以设置32G
docker run --name elasticsearch -p 9200:9200 -p 9300:9300 \
-e  "discovery.type=single-node" \
-e ES_JAVA_OPTS="-Xms64m -Xmx512m" \
-v /mydata/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /mydata/elasticsearch/data:/usr/share/elasticsearch/data \
-v  /mydata/elasticsearch/plugins:/usr/share/elasticsearch/plugins \
-d elasticsearch:7.4.2 


# 设置开机启动elasticsearch
docker update elasticsearch --restart=always

配置启动

# kibana指定了了ES交互端口9200  # 5601为kibana主页端口
docker run --name kibana -e ELASTICSEARCH_HOSTS=http://192.168.56.10:9200 -p 5601:5601 -d kibana:7.4.2


# 设置开机启动kibana
docker update kibana  --restart=always

测试

查看elasticsearch版本信息：http://10.235.140.206:9200/

{
  "name" : "85ba4fbaead7",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "yZ9iJWtdTVWH31coJ4Jm9Q",
  "version" : {
    "number" : "7.4.2",
    "build_flavor" : "default",
    "build_type" : "docker",
    "build_hash" : "2f90bbf7b93631e52bafb59b3b049cb44ec25e96",
    "build_date" : "2019-10-28T20:40:44.881551Z",
    "build_snapshot" : false,
    "lucene_version" : "8.2.0",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}

显示elasticsearch 节点信息: http://10.235.140.206:9200/_cat/nodes

127.0.0.1 15 90 8 0.18 0.28 0.35 dilm * 85ba4fbaead7
*代表是主节点

使用

_cat命令

GET /_cat/nodes：查看所有节点
GET /_cat/health：查看 es 健康状况
GET /_cat/master：查看主节点
GET /_cat/indices：查看所有索引  和show database效果类似

保存/查询文档

保存

保存一个数据，保存在哪个索引的哪个类型下（哪张数据库哪张表下），保存时用唯一标识指定

# 在customer索引下的external类型下保存1号数据
PUT customer/external/1
# POSTMAN输入
http://192.168.56.10:9200/customer/external/1
{
 "name":"John Doe"
}

PUT和POST区别

POST新增。
	如果不指定id，会自动生成id。指定id就会修改这个数据，并新增版本号；
	可以不指定id，不指定id时永远为创建
	指定不存在的id为创建
	指定存在的id为更新，而版本号会根据内容变没变而觉得版本号递增与否
	
PUT可以新增也可以修改。
	PUT必须指定id；由于PUT需要指定id，我们一般用来做修改操作，不指定id会报错。
	必须指定id
	版本号总会增加

测试

POST请求
http://192.168.56.10:9200/customer/external/1

{
 "name":"John Doe"
}
返回数据：
带有下划线开头的，称为元数据，反映了当前的基本信息。  
{
    "_index": "customer", 表明该数据在哪个数据库下；
    "_type": "external", 表明该数据在哪个类型下；
    "_id": "1",  表明被保存数据的id；
    "_version": 1,  被保存数据的版本
    "result": "created", 这里是创建了一条数据，如果重新put一条数据，则该状态会变为updated，并且版本号也会发生变化。
    "_shards": {
        "total": 2,
        "successful": 1,
        "failed": 0
    },
    "_seq_no": 0,
    "_primary_term": 1
}

查询

GET /customer/external/1

http://192.168.56.10:9200/customer/external/1

{
    "_index": "customer",
    "_type": "external",
    "_id": "1",
    "_version": 10,
    "_seq_no": 18,//并发控制字段，每次更新都会+1，用来做乐观锁
    "_primary_term": 6,//同上，主分片重新分配，如重启，就会变化
    "found": true,
    "_source": {
        "name": "John Doe"
    }
}

乐观锁用法：通过请求后面带上“?if_seq_no=1&if_primary_term=1”，
当序列号匹配的时候，才进行修改，否则不修改。
就是当并发操作的时候,第一次查到的seq_no和primary_term一致
才可以修改数据,不一致说明其他线程修改了数据

更新

POST customer/externel/1/_update
{
    "doc":{
        "name":"111"
    }
}
或者
POST customer/externel/1
{
       "name":"222"
}
或者
PUT customer/externel/1
{
       "name":"222"
}

POST更新文档，带有_update
	会对比原来的数据，和原来的相同，则不执行任何操作（version和_seq_no）都不变。

POST更新文档，不带_update
	在更新过程中，重复执行更新操作，数据也能够更新成功，不会和原来的数据进行对比。

PUT操作总会重新保存并增加version版本

看场景：
		对于大并发更新，不带update
		对于大并发查询偶尔更新，带update；对比更新，重新计算分配规则

删除

DELETE customer/external/1
DELETE customer
注：elasticsearch并没有提供删除类型的操作，只提供了删除索引和文档的操作。

数据迁移

#数据迁移
POST _reindex
{
  "source": {
    "index": "product"
  },
  "dest": {
    "index": "shopproduct"
  }
}

ES的批量操作——bulk

导入数据

POST http://192.168.56.10:9200/customer/external/_bulk

两行为一个整体
{"index":{"_id":"1"}}
{"name":"a"}
{"index":{"_id":"2"}}
{"name":"b"}
注意格式json和text均不可，要去kibana里Dev Tools
第一行:index表示添加操作,_id代表索引是1,
下面一行代表保存的数据是什么

语法格式：
{action:{metadata}}\n
{request body  }\n

{action:{metadata}}\n
{request body  }\n

这里的批量操作，当发生某一条执行发生失败时，
其他的数据仍然能够接着执行，也就是说彼此之间是独立的。

bulk api以此按顺序执行所有的action（动作）。
如果一个单个的动作因任何原因失败，它将继续处理它后面剩余的动作。
当bulk api返回时，它将提供每个动作的状态（与发送的顺序相同），
所以您可以检查是否一个指定的动作是否失败了。

在Kibana里面的Dev Tools里面进行测试
POST /customer/external/_bulk
{"index":{"_id":"1"}}
{"name":"John Doe"}
{"index":{"_id":"2"}}
{"name":"John Doe"}

结果
#! Deprecation: [types removal] Specifying types in bulk requests is deprecated.
{
  "took" : 318,  花费了多少ms
  "errors" : false, 没有发生任何错误
  "items" : [ 每个数据的结果
    {
      "index" : { 保存
        "_index" : "customer", 索引
        "_type" : "external", 类型
        "_id" : "1", 文档
        "_version" : 1, 版本
        "result" : "created", 创建
        "_shards" : {
          "total" : 2,
          "successful" : 1,
          "failed" : 0
        },
        "_seq_no" : 0,
        "_primary_term" : 1,
        "status" : 201 新建完成
      }
    },
    {
      "index" : { 第二条记录
        "_index" : "customer",
        "_type" : "external",
        "_id" : "2",
        "_version" : 1,
        "result" : "created",
        "_shards" : {
          "total" : 2,
          "successful" : 1,
          "failed" : 0
        },
        "_seq_no" : 1,
        "_primary_term" : 1,
        "status" : 201
      }
    }
  ]
}

导入官网模板的批量数据

官网的数据链接地址
https://github.com/elastic/elasticsearch/blob/v7.4.2/docs/src/test/resources/accounts.json

检索

ES支持两种基本方式检索；
	通过REST request uri 发送搜索参数 （uri +检索参数）；
	通过REST request body 来发送它们（uri+请求体）；

请求参数方式检索
GET bank/_search?q=*&sort=account_number:asc
说明：
q=* # 查询所有
sort # 排序字段
asc #升序

检索bank下所有信息，包括type和docs
GET bank/_search

返回内容：
	took – 花费多少ms搜索
	timed_out – 是否超时
	_shards – 多少分片被搜索了，以及多少成功/失败的搜索分片
	max_score –文档相关性最高得分
	hits.total.value - 多少匹配文档被找到
	hits.sort - 结果的排序key（列），没有的话按照score排序
	hits._score - 相关得分 (not applicable when using match_all)

GET bank/_search?q=*&sort=account_number:asc
检索了1000条数据，但是根据相关性算法，只返回10条

uri+请求体进行检索
GET /bank/_search
{
  "query": { "match_all": {} },
  "sort": [
    { "account_number": "asc" },
    { "balance":"desc"}
  ]
}

DSL领域特定语言

Elasticsearch提供了一个可以执行查询的Json风格的DSL(domain-specific language领域特定语言)。
这个被称为Query DSL，该查询语言非常全面。

语法

一个查询语句的典型结构
如果针对于某个字段，那么它的结构如下：
{
  QUERY_NAME:{   # 使用的功能
     FIELD_NAME:{  #  功能参数
       ARGUMENT:VALUE,
       ARGUMENT:VALUE,...
      }   
   }
}

示例  使用时不要加#注释内容
GET bank/_search
{
  "query": {  #  查询的字段
    "match_all": {}
  },
  "from": 0,  # 从第几条文档开始查
  "size": 5,
  "_source":["balance"],
  "sort": [
    {
      "account_number": {  # 返回结果按哪个列排序
        "order": "desc"  # 降序
      }
    }
  ]
}
_source为要返回的字段

query定义如何查询；
	match_all查询类型【代表查询所有的索引】，
		es中可以在query中组合非常多的查询类型完成复杂查询；
	除了query参数之外，我们可也传递其他的参数以改变查询结果，
			如sort，size；from+size限定，完成分页功能；
	sort排序，多字段排序，会在前序字段相等时后续字段内部排序，否则以前序为准；

query/match匹配查询

如果是非字符串，会进行精确匹配。如果是字符串，会进行全文检索

基本类型（非字符串），精确控制
GET bank/_search
{
  "query": {
    "match": {
      "account_number": "20"
    }
  }
}

字符串，全文检索
全文检索，最终会按照评分进行排序，会对检索条件进行分词匹配。

GET bank/_search
{
  "query": {
    "match": {
      "address": "kings"
    }
  }
}

query/match_phrase [不拆分匹配]

将需要匹配的值当成一整个单词（不分词）进行检索
	match_phrase：不拆分字符串进行检索
	字段.keyword：必须全匹配上才检索成功
	前面的是包含mill或road就查出来，我们现在要都包含才查出

GET bank/_search
{
  "query": {
    "match_phrase": {
      "address": "mill road"   #  就是说不要匹配只有mill或只有road的，要匹配mill road一整个子串
    }
  }
}

query/multi_math【多字段匹配】

state或者address中包含mill，并且在查询过程中，会对于查询条件进行分词。
GET bank/_search
{
  "query": {
    "multi_match": {  # 前面的match仅指定了一个字段。
      "query": "mill",
      "fields": [ # state和address有mill子串  不要求都有
        "state",
        "address"
      ]
    }
  }
}

query/bool/must复合查询

复合语句可以合并任何其他查询语句，包括复合语句。
这也就意味着，复合语句之间可以互相嵌套，可以表达非常复杂的逻辑。

	must：必须达到must所列举的所有条件
	must_not：必须不匹配must_not所列举的所有条件。
	should：应该满足should所列举的条件。满足条件最好，不满足也可以，满足得分更高

例如
GET bank/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "gender": "M"
          }
        },
        {
          "match": {
            "address": "mill"
          }
        }
      ],
      "must_not": [
        {
          "match": {
            "age": "18"
          }
        }
      ],
      "should": [
        {
          "match": {
            "lastname": "Wallace"
          }
        }
      ]
    }
  }
}

query/filter【结果过滤】

	must 贡献得分
	should 贡献得分
	must_not 不贡献得分
	filter 不贡献得分
	
上面的must和should影响相关性得分，而must_not仅仅是一个filter ，不贡献得分
must改为filter就使must不贡献得分
如果只有filter条件的话，我们会发现得分都是0
一个key多个值可以用terms
并不是所有的查询都需要产生分数，特别是哪些仅用于filtering过滤的文档。
为了不计算分数，elasticsearch会自动检查场景并且优化查询的执行。
	不参与评分更快

query/term

和match一样。匹配某个属性的值。
		全文检索字段用match，
		其他非text字段匹配用term。
不要使用term来进行文本字段查询
es默认存储text值时用分词分析，所以要搜索text值，使用match

字段.keyword：要一一匹配到
match_phrase：子串包含即可

aggregations（执行聚合）

聚合提供了从数据中分组和提取数据的能力。
最简单的聚合方法大致等于SQL Group by和SQL聚合函数。

在elasticsearch中，执行搜索返回this（命中结果），并且同时返回聚合结果，
把以响应中的所有hits（命中结果）分隔开的能力。
这是非常强大且有效的，你可以执行查询和多个聚合，
并且在一次使用中得到各自的（任何一个的）返回结果，
使用一次简洁和简化的API啦避免网络往返。

语法

"aggs":{ # 聚合
    "aggs_name":{ # 这次聚合的名字，方便展示在结果集中
        "AGG_TYPE":{} # 聚合的类型(avg,term,terms)
     }
}

terms：看值的可能性分布，会合并锁查字段，给出计数即可
avg：看值的分布平均

例：搜索address中包含mill的所有人的年龄分布以及平均年龄，但不显示这些人的详情

# 分别为包含mill、，平均年龄、
GET bank/_search
{
  "query": { # 查询出包含mill的
    "match": {
      "address": "Mill"
    }
  },
  "aggs": { #基于查询聚合
    "ageAgg": {  # 聚合的名字，随便起
      "terms": { # 看值的可能性分布
        "field": "age",
        "size": 10
      }
    },
    "ageAvg": { 
      "avg": { # 看age值的平均
        "field": "age"
      }
    },
    "balanceAvg": {
      "avg": { # 看balance的平均
        "field": "balance"
      }
    }
  },
  "size": 0  # 不看详情
}

output

{
  "took" : 2,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 4, // 命中4条
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [ ]
  },
  "aggregations" : {
    "ageAgg" : { // 第一个聚合的结果
      "doc_count_error_upper_bound" : 0,
      "sum_other_doc_count" : 0,
      "buckets" : [
        {
          "key" : 38,  # age为38的有2条
          "doc_count" : 2
        },
        {
          "key" : 28,
          "doc_count" : 1
        },
        {
          "key" : 32,
          "doc_count" : 1
        }
      ]
    },
    "ageAvg" : { // 第二个聚合的结果
      "value" : 34.0  # balance字段的平均值是34
    },
    "balanceAvg" : {
      "value" : 25208.0
    }
  }
}

按照年龄聚合，并且求这些年龄段的这些人的平均薪资

写到一个聚合里是基于上个聚合进行子聚合。
下面求每个age分布的平均balance

GET bank/_search
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "ageAgg": {
      "terms": { # 看分布
        "field": "age",
        "size": 100
      },
      "aggs": { # 与terms并列
        "ageAvg": { #平均
          "avg": {
            "field": "balance"
          }
        }
      }
    }
  },
  "size": 0
}

复杂子聚合：查出所有年龄分布，并且这些年龄段中M的平均薪资和F的平均薪资以及这个年龄段的总体平均薪资

GET bank/_search
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "ageAgg": {
      "terms": {  #  看age分布
        "field": "age",
        "size": 100
      },
      "aggs": { # 子聚合
        "genderAgg": {
          "terms": { # 看gender分布
            "field": "gender.keyword" # 注意这里，文本字段应该用.keyword
          },
          "aggs": { # 子聚合
            "balanceAvg": {
              "avg": { # 男性的平均
                "field": "balance"
              }
            }
          }
        },
        "ageBalanceAvg": {
          "avg": { #age分布的平均（男女）
            "field": "balance"
          }
        }
      }
    }
  },
  "size": 0
}