ElasticSearch-入门

ELASTIC SEARCH

一、ES入门

1、简介

mysql用作持久化存储，ES用作检索

基本概念：index库>type表>document文档

index索引

动词：相当于mysql的insert

名词：相当于mysql的db

Type类型

在index中，可以定义一个或多个类型

类似于mysql的table，每一种类型的数据放在一起

Document文档

保存在某个index下，某种type的一个数据document，文档是json格式的，document就像是mysql中的某个table里面的内容。每一行对应的列叫属性

为什么ES搜索快？倒排索引

2、安装elastic search

dokcer中安装elastic search

（1）下载ealastic search（存储和检索）和kibana（可视化检索）

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

（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/

（3）启动Elastic search

# 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

因为容器里的文件映射到了外面，所以删除容器和新建容器数据还在

第一次查docker ps启动了，第二次查的时候发现关闭了，docker logs elasticsearch

http://192.168.56.10:9200

数据挂载到外面，但是访问权限不足

把/mydata/elasticsearch下文件夹的权限设置好，上面已经设置过了

（4）启动kibana：

# kibana指定了了ES交互端口9200  # 5600位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

（5）测试

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

{
    "name": "66718a266132",
    "cluster_name": "elasticsearch",
    "cluster_uuid": "xhDnsLynQ3WyRdYmQk5xhQ",
    "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://192.168.56.10:9200/_cat/nodes

127.0.0.1 14 99 25 0.29 0.40 0.22 dilm * 66718a26613266718a266132代表上面的结点*代表是主节点

kibana

访问Kibana： http://192.168.56.10:5601/app/kibana

3、初步检索

1）检索es信息

（1）GET /_cat/nodes：查看所有节点

如：http://192.168.56.10:9200/_cat/nodes

可以直接浏览器输入上面的url，也可以在kibana中输入GET /_cat/nodes

127.0.0.1 12 97 3 0.00 0.01 0.05 dilm * 66718a266132

66718a266132代表结点
*代表是主节点

（2）GET /_cat/health：查看es健康状况

如： http://192.168.56.10:9200/_cat/health

1613741055 13:24:15 elasticsearch green 1 1 0 0 0 0 0 0 - 100.0%

注：green表示健康值正常

（3）GET /_cat/master：查看主节点

如： http://192.168.56.10:9200/_cat/master

089F76WwSaiJcO6Crk7MpA 127.0.0.1 127.0.0.1 66718a266132主节点唯一编号虚拟机地址

（4）GET/_cat/indicies：查看所有索引

等价于mysql数据库的show databases;

如：http://192.168.56.10:9200/_cat/indices

green  open .kibana_task_manager_1   DhtDmKrsRDOUHPJm1EFVqQ 1 0 2 3 40.8kb 40.8kbgreen  open .apm-agent-configuration vxzRbo9sQ1SvMtGkx6aAHQ 1 0 0 0   230b   230bgreen  open .kibana_1                rdJ5pejQSKWjKxRtx-EIkQ 1 0 5 1 18.2kb 18.2kb这3个索引是kibana创建的

2）新增文档

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

# 在customer索引下的external类型下保存1号数据PUT customer/external/1# 发请求：POSTMAN输入http://192.168.56.10:9200/customer/external/1# json格式数据{ "name":"mhk"}

PUT和POST区别

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

PUT方式，创建数据成功后，显示201 created表示插入记录成功。

返回数据：
带有下划线开头的，称为元数据，反映了当前的基本信息。  
{
    "_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
}

POST方式：

1）添加数据的时候，不指定ID，会自动的生成id，并且类型是新增：

​ 再次使用POST插入数据，不指定ID，仍然是新增的：

2）添加数据的时候，指定ID，会使用该id，并且类型是新增：

​ 再次使用POST插入数据，指定同样的ID，类型为updated

3）查看文档

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”，当序列号匹配的时候，才进行修改，否则不修改。

4）更新文档_update

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

4.1.不同：

1)带有update情况下

POST操作会对比源文档数据，如果相同不会有什么操作，文档version不增加。PUT操作总会重新保存并增加version版本

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

4.2.看场景：

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

5）删除文档或索引

DELETE customer/external/1DELETE customer

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

6）ES的批量操作——bulk

匹配导入数据

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

6.1.语法格式：

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

6.2.例：

两行为一个整体{"index":{"_id":"1"}}{"name":"a"}{"index":{"_id":"2"}}{"name":"b"}注意格式json和text均不可，要去kibana里Dev Tools

执行结果

#! 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
      }
    }
  ]
}

二、进阶检索

3.1）search检索文档

ES支持两种基本方式检索；

• 通过REST request uri 发送搜索参4数 （uri +检索参数）；
• 通过REST request body 来发送它们（uri+请求体）；

信息检索

请求参数方式检索GET bank/_search?q=*&sort=account_number:asc说明：q=* # 查询所有sort # 排序字段asc #升序检索bank下所有信息，包括type和docsGET bank/_search

返回内容：

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

uri+请求体进行检索

GET /bank/_search{  "query": { "match_all": {} },  "sort": [    { "account_number": "asc" },    { "balance":"desc"}  ]}

3.2）DSL领域特定语言

（1）基本语法格式

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

示例

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

query定义如何查询；

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

（2）from 返回部分字段

GET bank/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0,
  "size": 5,
  "sort": [
    {
      "account_number": {
        "order": "desc"
      }
    }
  ],
  "_source": ["balance","firstname"]
}

（3）query/match 匹配查询

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

3.1）基本类型（非字符串），精确控制

GET bank/_search{  "query": {    "match": {      "account_number": "20"    }  }}

3.2）字符串，全文检索

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

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

（4）query/match_phrase 不拆分匹配

将需要匹配的值当成一整个单词（不分词）进行检索

• match_phrase：不拆分字符串进行检索
• 字段.keyword：必须全匹配上才检索成功

前面的是包含mill或road就查出来，我们现在要都包含才查出

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

（5）query/multi_math 多字段匹配

例：

state或者address中包含mill，并且在查询过程中，会对于查询条件进行分词。

GET bank/_search{  "query": {    "multi_match": {  # 前面的match仅指定了一个字段。      "query": "mill",      "fields": [ # state和address有mill子串  不要求都有        "state",        "address"      ]    }  }}

（6）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"
          }
        }
      ]
    }
  }
}

（7）query/filter 结果过滤

• must 贡献得分
• should 贡献得分
• must_not 不贡献得分
• filter 不贡献得分

filter在使用过程中，并不会计算相关性得分

如果只有filter条件的话，我们会发现得分都是0

并不是所有的查询都需要产生分数，特别是哪些仅用于filtering过滤的文档。不参与评分更快

（8）query/term

和match一样。匹配某个属性的值。

• 全文检索字段用match，
• 其他非text字段匹配用term。

不要使用term来进行文本字段查询

es默认存储text值时用分词分析，所以要搜索text值，使用match

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

使用term匹配查询

GET bank/_search{  "query": {    "term": {      "address": "mill Road"    }  }}

（9）aggs/agg1（聚合）

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

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

9.1.aggs：执行聚合。

聚合语法如下：

"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  # 不看详情
}

三、Mapping字段映射

（1）字段类型

• 核心类型
• 复合类型
• 地理类型
• 特定类型

核心数据类型

（1）字符串

text ⽤于全⽂索引，搜索时会自动使用分词器进⾏分词再匹配keyword 不分词，搜索时需要匹配完整的值

（2）数值型

整型： byte，short，integer，long浮点型： float, half_float, scaled_float，double

（3）日期类型：date

（4）范围型

integer_range， long_range， float_range，double_range，date_range

gt是大于，lt是小于，e是equals等于。

age_limit的区间包含了此值的文档都算是匹配。

（5）布尔

boolean

（6）二进制

binary 会把值当做经过 base64 编码的字符串，默认不存储，且不可搜索

复杂数据类型

（1）对象

object一个对象中可以嵌套对象。

（2）数组

Array

嵌套类型

nested 用于json对象数组

（2）映射

Mapping(映射)是用来定义一个文档（document），以及它所包含的属性（field）是如何存储和索引的。比如：使用maping来定义：

• 哪些字符串属性应该被看做全文本属性（full text fields）；

• 哪些属性包含数字，日期或地理位置；

• 文档中的所有属性是否都嫩被索引（all 配置）；

• 日期的格式；

• 自定义映射规则来执行动态添加属性；

• 查看mapping信息：GET bak/_mapping

  {
    "bank" : {
      "mappings" : {
        "properties" : {
          "account_number" : {
            "type" : "long" # long类型
          },
          "address" : {
            "type" : "text", # 文本类型，会进行全文检索，进行分词
            "fields" : {
              "keyword" : { # addrss.keyword
                "type" : "keyword",  # 该字段必须全部匹配到
                "ignore_above" : 256
              }
            }
          }
    	}
  	  }
    }
  }

（3）新版本改变

ElasticSearch7-去掉type概念

关系型数据库中两个数据表示是独立的，即使他们里面有相同名称的列也不影响使用，但ES中不是这样的。elasticsearch是基于Lucene开发的搜索引擎，而ES中不同type下名称相同的filed最终在Lucene中的处理方式是一样的。

两个不同type下的两个user_name，在ES同一个索引下其实被认为是同一个filed，你必须在两个不同的type中定义相同的filed映射。否则，不同type中的相同字段名称就会在处理中出现冲突的情况，导致Lucene处理效率下降。

去掉type就是为了提高ES处理数据的效率。

3.1.创建映射PUT /my_index

第一次存储数据的时候es就猜出了映射

第一次存储数据前可以指定映射

创建索引并指定映射

PUT /my_index{  "mappings": {    "properties": {      "age": {        "type": "integer"      },      "email": {        "type": "keyword" # 指定为keyword      },      "name": {        "type": "text" # 全文检索。保存时候分词，检索时候进行分词匹配      }    }  }}

3.2.查看映射GET /my_index

3.3.添加新的字段映射PUT /my_index/_mapping

3.4.不能更新映射

对于已经存在的字段映射，我们不能更新。更新必须创建新的索引，进行数据迁移。

3.5.数据迁移

先创建new_twitter的正确映射。

然后使用如下方式进行数据迁移。

6.0以后写法
POST reindex
{
  "source":{
      "index":"twitter"
   },
  "dest":{
      "index":"new_twitters"
   }
}


老版本写法
POST reindex
{
  "source":{
      "index":"twitter",
      "twitter":"twitter"
   },
  "dest":{
      "index":"new_twitters"
   }
}

四、分词

一个tokenizer（分词器）接收一个字符流，将之分割为独立的tokens（词元，通常是独立的单词），然后输出tokens流。

elasticsearch提供了很多内置的分词器（标准分词器），可以用来构建custom analyzers（自定义分词器）。

例：

默认的：

POST _analyze{  "analyzer": "standard",  "text": "The 2 Brown-Foxes bone."}

对于中文，我们需要安装额外的分词器

1、安装ik分词器

https://github.com/medcl/elasticsearch-analysis-ik/releases

2、测试分词器

GET _analyze
{
   "analyzer": "ik_smart", 
   "text":"我是中国人"
}

GET _analyze
{
   "analyzer": "ik_max_word", 
   "text":"我是中国人"
}

3、自定义词库

修改/usr/share/elasticsearch/plugins/ik/config中的IKAnalyzer.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
	<comment>IK Analyzer 扩展配置</comment>
	<!--用户可以在这里配置自己的扩展字典 -->
	<entry key="ext_dict"> </entry>
	 <!--用户可以在这里配置自己的扩展停止词字典-->
	<entry key="ext_stopwords"></entry>
	<!--用户可以在这里配置远程扩展字典 -->
	<entry key="remote_ext_dict">http://192.168.56.10/es/fenci.txt</entry> 
	<!--用户可以在这里配置远程扩展停止词字典-->
	<!-- <entry key="remote_ext_stopwords">words_location</entry> -->
</properties>

修改完成后，需要重启elasticsearch容器，否则修改不生效。docker restart elasticsearch

五、elasticsearch-Rest-Client

java操作es有两种方式

1）9300: TCP

spring-data-elasticsearch:transport-api.jar;
    springboot版本不同，ransport-api.jar不同，不能适配es版本
    7.x已经不建议使用，8以后就要废弃

2）9200: HTTP

有诸多包

jestClient: 非官方，更新慢；
RestTemplate：模拟HTTP请求，ES很多操作需要自己封装，麻烦；
HttpClient：同上；
Elasticsearch-Rest-Client：官方RestClient，封装了ES操作，API层次分明，上手简单；

最终选择Elasticsearch-Rest-Client（elasticsearch-rest-high-level-client

六、SpringBoot整合ElasticSearch

选择依赖web，但不要在里面选择es

1、导入依赖

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
    <version>7.4.2</version>
</dependency>

在spring-boot-dependencies中所依赖的ES版本位6.8.5，要改掉

<properties>
    <java.version>1.8</java.version>
    <elasticsearch.version>7.4.2</elasticsearch.version>
</properties>

2.配置类

@Configuration
public class GuliESConfig {

    public static final RequestOptions COMMON_OPTIONS;

    static {
        RequestOptions.Builder builder = RequestOptions.DEFAULT.toBuilder();

        COMMON_OPTIONS = builder.build();
    }

    @Bean
    public RestHighLevelClient esRestClient() {

        RestClientBuilder builder = null;
        // 可以指定多个es
        builder = RestClient.builder(new HttpHost(host, 9200, "http"));

        RestHighLevelClient client = new RestHighLevelClient(builder);
        return client;
    }
}