Elasticsearch

（3）百度：百度目前广泛使用ElasticSearch作为文本数据分析，采集百度所有服务器上的各类指标数据及用户自定义数据，通过对各种数据进行多维分析展示，辅助定位分析实例异常或业务层面异常。目前覆盖百度内部20多个业务线（包括casio、云分析、网盟、预测、文库、直达号、钱包、风控等），单集群最大100台机器，200个ES节点，每天导入30TB+数据

（4）新浪使用ES 分析处理32亿条实时日志

（5）阿里使用ES 构建挖财自己的日志采集和分析体系

（三）同类产品

Solr、ElasticSearch、Hermes（腾讯）（实时检索分析）

1、Solr、ES

①. 源自搜索引擎，侧重搜索与全文检索。
②. 数据规模从几百万到千万不等，数据量过亿的集群特别少。

有可能存在个别系统数据量过亿，但这并不是普遍现象（就像Oracle的表里的数据规模有可能超过Hive里一样，但需要小型机）。

2、Hermes

①. 一个基于大索引技术的海量数据实时检索分析平台。侧重数据分析。

②. 数据规模从几亿到万亿不等。最小的表也是千万级别。

在腾讯17 台TS5机器，就可以处理每天450亿的数据(每条数据1kb左右)，数据可以保存一个月之久。

3、Solr、ES区别

全文检索、搜索、分析。基于lucene

Solr 利用 Zookeeper 进行分布式管理，而 Elasticsearch 自身带有分布式协调管理功能;
Solr 支持更多格式的数据，而 Elasticsearch 仅支持json文件格式；
Solr 官方提供的功能更多，而 Elasticsearch 本身更注重于核心功能，高级功能多有第三方插件提供；
Solr 在传统的搜索应用中表现好于 Elasticsearch，但在处理实时搜索应用时效率明显低于 Elasticsearch-----附近的人

Lucene是一个开放源代码的全文检索引擎工具包，但它不是一个完整的全文检索引擎，而是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎，部分文本分析引擎、搜索引擎

（四）基本概念

1 、 Index （索引）

动词，相当于 MySQL 中的 insert ；

名词，相当于 MySQL 中的 Database

2 、 Type （类型）

在 Index （索引）中，可以定义一个或多个类型。

类似于 MySQL 中的 Table ；每一种类型的数据放在一起；

3 、 Document （文档）

保存在某个索引（ Index ）下，某种类型（ Type ）的一个数据（ Document ），文档是 JSON 格

式的， Document 就像是 MySQL 中的某个 Table 里面的内容；

4 、倒排索引机制

将每个记录分解为单词，采用倒排索引机制，比如搜索红海特工行动，3和5都有了两个单词命中，但是3的命中率为2/3，5的命中率为2/4，因为3的相关性得分更高

二、Docker 安装 Es

（一）下载镜像文件

docker pull elasticsearch:7.4.2 // 存储和检索数据

docker pull kibana:7.4.2 //可视化检索数据

（二）创建实例

1 、 ElasticSearch

mkdir -p /mydata/elasticsearch/config
mkdir -p /mydata/elasticsearch/data
echo "http.host: 0.0.0.0" >> /mydata/elasticsearch/config/elasticsearch.yml
chmod -R 777 /mydata/elasticsearch/ 保证权限
启动elasticsearch
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

以后再外面装好插件重启即可；

特别注意：

-e ES_JAVA_OPTS="-Xms64m -Xmx256m" \ 测试环境下，设置 ES 的初始内存和最大内存，否则导致内存占用过大启动不了 ES

访问http://ip:9200出现如下界面表示启动elasticSearch成功

2 、 Kibana

docker run --name kibana -e ELASTICSEARCH_HOSTS=http://192.168.56.10:9200 -p 5601:5601 \
-d kibana:7.4.2

http://192.168.56.10:9200 一定改为自己虚拟机的地址

访问http://ip:5601出现如下界面表示启动 Kibana 成功、

三、初步检索

（一）_cat

GET /_cat/nodes：查看所有节点
GET /_cat/health：查看 es 健康状况
GET /_cat/master：查看主节点
GET /_cat/indices：查看所有索引   相当于MySQL中的show databases;

（二）索引一个文档（保存）

保存一个数据，保存在哪个索引的哪个类型下，指定用哪个唯一标识

PUT customer/external/1 ；在 customer 索引下的 external 类型下保存 1 号数据如下

{ 
"name": "John Doe"
}

使用postman，访问http://ip:9200/customer/external/1

PUT 和 POST 都可以，

POST 新增。如果不指定 id，会自动生成 id。指定 id 就会修改这个数据，并新增版本号

PUT 可以新增可以修改。PUT 必须指定 id；由于 PUT 需要指定 id，我们一般都用来做修改

操作，不指定 id 会报错。

（三）查询文档

GET customer/external/1

结果

{
    "_index": "customer",
    "_type": "external",
    "_id": "1",
    "_version": 1,
    "_seq_no": 0,
    "_primary_term": 1,
    "found": true,
    "_source": {
        "name": "John Doe"
    }
}

（四）更新文档

方式一 Post带上_update

这种方式更新时会检查更新内容与原内容是否一样，一样的话不做任何改变，包括version、seq_no都不改变，而且更新时内容需要放在doc内

POST customer/external/1/_update
{ 
    "doc":{ 
        "name": "John Doew"
    }
}

方式二 post和put指定id进行更新

POST customer/external/1
{ 
    "name": "John Doe2"
}
或者
PUT customer/external/1
{ 
    "name": "John Doe"
}

（五）删除文档&索引

es中没有提供删除类型，只能删除索引或者文档

DELETE customer/external/1
DELETE customer

（六）bulk 批量 API

bulk API 以此按顺序执行所有的 action （动作）。如果一个单个的动作因任何原因而失败，

它将继续处理它后面剩余的动作。当 bulk API 返回时，它将提供每个动作的状态（与发送

的顺序相同），所以您可以检查是否一个指定的动作是不是失败了。

POST customer/external/_bulk
{"index":{"_id":"1"}}
{"name": "John Doe" }
{"index":{"_id":"2"}}
{"name": "Jane Doe" }

语法格式如下：

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

复杂案例

POST /_bulk
{ "delete": { "_index": "website", "_type": "blog", "_id": "123" }}
{ "create": { "_index": "website", "_type": "blog", "_id": "123" }}
{ "title": "My first blog post" }
{ "index": { "_index": "website", "_type": "blog" }}
{ "title": "My second blog post" }
{ "update": { "_index": "website", "_type": "blog", "_id": "123"} }
{ "doc" : {"title" : "My updated blog post"} }

导入批量测试数据es测试数据.json · 坐看云起时/common_content - Gitee.com

POST bank/account/_bulk

四、进阶索引

（一）SearchAPI

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

一个是通过使用 REST request URI 发送搜索参数（uri+检索参数）
另一个是通过使用 REST request body 来发送它们（uri+请求体）

方式一、一切检索从_search 开始

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

GET bank/_search?q=*&sort=account_number:asc 请求参数方式检索

响应结果

解释：

took - Elasticsearch 执行搜索的时间（毫秒）

time_out - 告诉我们搜索是否超时

_shards - 告诉我们多少个分片被搜索了，以及统计了成功 / 失败的搜索分片

hits - 搜索结果

hits.total - 搜索结果

hits.hits - 实际的搜索结果数组（默认为前 10 的文档，相当于mysql的分页查询）

sort - 结果的排序 key （键）（没有则按 score 排序）

score 和 max_score – 相关性得分和最高得分（全文检索用）

方式二、uri+请求体进行检索

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

（二）Query DSL

Elasticsearch 提供了一个可以执行查询的 Json 风格的 DSL （ domain-specific language 领域特定语言）。这个被称为 Query DSL 。该查询语言非常全面，并且刚开始的时候感觉有点复杂，真正学好它的方法是从一些基础的示例开始的。

1、基本语法格式

一个查询语句的典型结构

{
    QUERY_NAME: {
        ARGUMENT: VALUE, 
        ARGUMENT: VALUE,
        ... 
    }
}

如果是针对某个字段，那么它的结构如下：

{
    QUERY_NAME: {
        FIELD_NAME: {
            ARGUMENT: VALUE, 
            ARGUMENT: VALUE,
            ... 
        }
    }
}

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


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

2、返回部分字段

GET bank/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0,
  "size": 5,
  "_source": [
    "age",
    "balance"
  ]
}

3、match【匹配查询】

基本类型（非字符串），精确匹配

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

字符串，全文检索

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

最终查询出 address 中包含 mill 单词的所有记录

match 当搜索字符串类型的时候，会进行全文检索，并且每条记录有相关性得分

字符串，多个单词（分词+全文检索）

GET bank/_search
{
  "query": {
    "match": {
      "address": "mill road"
    }
  }
}

最终查询出 address 中包含 mill 或者 road 或者 mill road 的所有记录，并给出相关性得分

也可通过match实现精确的字符串匹配

GET bank/_search
{
  "query": {
    "match": {
      "address.keyword": "mill road"
    }
  }
}

4、match_phrase【短语匹配】

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

GET bank/_search
{
  "query": {
    "match_phrase": {
      "address": "mill road"
    }
  }
}

查出 address 中包含 mill road 的所有记录，并给出相关性得分

5、multi_match【多字段匹配】

GET bank/_search
{
  "query": {
    "multi_match": {
      "query": "mill",
      "fields": [
        "state",
        "address"
      ]
    }
  }
}

state 或者 address 包含 mill

6、bool【复合查询】

bool 用来做复合查询：

复合语句可以合并任何其它查询语句，包括复合语句，了解这一点是很重要的。这就意味

着，复合语句之间可以互相嵌套，可以表达非常复杂的逻辑。

GET bank/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "address": "mill"
          }
        },
        {
          "match": {
            "gender": "M"
          }
        }
      ],
      "should": [
        {
          "match": {
            "address": "lane"
          }
        }
      ],
      "must_not": [
        {
          "match": {
            "email": "baluba.com"
          }
        }
      ]
    }
  }
}

must：必须达到 must 列举的所有条件

should：应该达到 should 列举的条件，如果达到会增加相关文档的评分，并不会改变查询的结果。如果 query 中只有 should 且只有一种匹配规则，那么 should 的条件就会被作为默认匹配条件而去改变查询结果
must_not 必须不是指定的情况

并不是所有的查询都需要产生分数，特别是那些仅用于 “ filtering ” （过滤）的文档。为了不

计算分数 Elasticsearch 会自动检查场景并且优化查询的执行。

GET bank/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "address": "mill"
          }
        }
      ],
      "filter": {
        "range": {
          "balance": {
            "gte": 10000,
            "lte": 20000
          }
        }
      }
    }
  }
}

7、term

和 match 一样。匹配某个属性的值。全文检索字段用 match，其他非 text 字段匹配用 term(规范)。

GET bank/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "term": {
            "age": {
              "value": "28"
            }
          }
        },
        {
          "match": {
            "address": "990 Mill Road"
          }
        }
      ]
    }
  }
}

8、aggregations（执行聚合）

聚合提供了从数据中分组和提取数据的能力。最简单的聚合方法大致等于 SQL GROUP BY 和 SQL 聚合函数。在 Elasticsearch 中，您有执行搜索返回 hits （命中结果），并且同时返回聚合结果，把一个响应中的所有 hits （命中结果）分隔开的能力。这是非常强大且有效的，您可以执行查询和多个聚合，并且在一次使用中得到各自的（任何一个的）返回结果，使用一次简洁和简化的 API 来避免网络往返。

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

GET bank/_search
{
  "query": {
    "match": {
      "address": "mill"
    }
  },
  "aggs": {
    "group_by_state": {
      "terms": {
        "field": "age"
      }
    },
    "avg_age": {
      "avg": {
        "field": "age"
      }
    }
  },
  "size": 0
}




size：0 不显示搜索数据
aggs：执行聚合。聚合语法如下
"aggs": { 
    "aggs_name 这次聚合的名字，方便展示在结果集中": { 
        "AGG_TYPE 聚合的类型（avg,term,terms）": {}
    }
}

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

GET bank/account/_search
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "age_avg": {
      "terms": {
        "field": "age",
        "size": 1000
      },
      "aggs": {
        "banlances_avg": {
          "avg": {
            "field": "balance"
          }
        }
      }
    }
  },
  "size": 1000
}

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

GET bank/account/_search
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "age_agg": {
      "terms": {
        "field": "age",
        "size": 100
      },
      "aggs": {
        "gender_agg": {
          "terms": {
            "field": "gender.keyword",
            "size": 100
          },
          "aggs": {
            "balance_avg": {
              "avg": {
                "field": "balance"
              }
            }
          }
        },
        "balance_avg": {
          "avg": {
            "field": "balance"
          }
        }
      }
    }
  },
  "size": 1000
}

五、mapping

（一）字段类型

多字段
通常用于为不同目的用不同的方法索同一个字段，如，string 字段可以映为一个 text 字段用于全文检索，同样可以映射为一个 keyword 字段用于排序和聚合。另外，你可以使用 standard analyzer,english analyzer,french analyzer来索引一个text字段
这就是muti-fields的目的。大多数的数据类型通过fields参数来支持muti-fields。

（二）映射

Mapping （映射）

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

哪些字符串属性应该被看做全文本属性（full text fields）。
哪些属性包含数字，日期或者地理位置。
文档中的所有属性是否都能被索引（_all 配置）。
日期的格式。
自定义映射规则来执行动态添加属性。

1、查看mapping信息

GET bank/_mapping

2、修改 mapping 信息

Mapping | Elasticsearch Guide [8.9] | Elastic

（三）新版本改变

Es7 及以上移除了 type 的概念。

关系型数据库中两个数据表示是独立的，即使他们里面有相同名称的列也不影响使用，但 ES 中不是这样的。elasticsearch 是基于 Lucene 开发的搜索引擎，而 ES 中不同 type下名称相同的 filed 最终在 Lucene 中的处理方式是一样的。
- 两个不同 type 下的两个 user_name，在 ES 同一个索引下其实被认为是同一个 filed，你必须在两个不同的 type 中定义相同的 filed 映射。否则，不同 type 中的相同字段名称就会在处理中出现冲突的情况，导致 Lucene 处理效率下降。
- 去掉 type 就是为了提高 ES 处理数据的效率。

Elasticsearch 7.x

URL 中的 type 参数为可选。比如，索引一个文档不再要求提供文档类型。

Elasticsearch 8.x

不再支持 URL 中的 type 参数。

解决：

1 ）、将索引从多类型迁移到单类型，每种类型文档一个独立索引

2 ）、将已存在的索引下的类型数据，全部迁移到指定位置即可。详见数据迁移

1、创建映射

PUT /my-index
{
  "mappings": {
    "properties": {
      "age": {
        "type": "integer"
      },
      "email": {
        "type": "keyword"
      },
      "name": {
        "type": "text"
      }
    }
  }
}

2、添加新的字段映射

PUT /my-index/_mapping
{
  "properties": {
    "employee-id": {
      "type": "keyword",
      "index": false
    }
  }
}

3、更新映射

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

4、数据迁移

先创建出 new_twitter 的正确映射。然后使用如下方式进行数据迁移

POST _reindex
{
  "source": {
    "index": "twitter"
  },
  "dest": {
    "index": "new_twitter"
  }
}

将旧索引的 type 下的数据进行迁移

POST _reindex
{
  "source": {
    "index": "twitter",
    "type": "tweet"
  },
  "dest": {
    "index": "tweets"
  }
}

六、分词

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

例如， whitespace tokenizer 遇到空白字符时分割文本。它会将文本 " Quick brown fox! " 分割为 [ Quick , brown , fox! ] 。

该 tokenizer （分词器）还负责记录各个 term （词条）的顺序或 position 位置（用于 phrase 短语和 word proximity 词近邻查询），以及 term （词条）所代表的原始 word （单词）的 start （起始）和 end （结束）的 character offsets （字符偏移量）（用于高亮显示搜索的内容）。 Elasticsearch 提供了很多内置的分词器，可以用来构建 custom analyzers （自定义分词器）。

（一）安装ik分词器

注意： 不能用默认 elasticsearch-plugin install xxx.zip 进行自动安装

https://github.com/medcl/elasticsearch-analysis-ik/releases?after=v6.4.2 对应 es 版本安装

进入 es 容器内部 plugins 目录

docker exec -it 容器 id /bin/bash

wget

https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.4.2/elasticsearch-anal

ysis-ik-7.4.2.zip

unzip 下载的文件

rm –rf *.zip

mv elasticsearch/ ik

可以确认是否安装好了分词器

cd ../bin

elasticsearch plugin list ：即可列出系统的分词器

（二）测试分词器

使用默认

POST _analyze
{
  "text": "我是中国人"
}

使用分词器

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

另外一个分词器 ik_max_word

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

能够看出不同的分词器，分词有明显的区别，所以以后定义一个索引不能再使用默认的 mapping 了，要手工建立 mapping, 因为要选择分词器。

七、Elasticsearch-Rest-Client

1 ）、 9300 ： TCP

spring-data-elasticsearch:transport-api.jar；
springboot 版本不同， transport-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 ）

https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/java-rest-high.html

（一）springboot整合

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

（二）配置

@Bean
RestHighLevelClient client() {
    RestClientBuilder builder = RestClient.builder(new HttpHost("192.168.56.10", 9200, "http"));
    return new RestHighLevelClient(builder);
}

（三）使用

@Test
void test1() throws IOException {
    Product product = new Product();
    product.setSpuName("华为");
    product.setId(10L);
    IndexRequest request = new IndexRequest("product").id("20").source("spuName","华为","id",20L);
    try {
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);
        System.out.println(request.toString());
        IndexResponse response2 = client.index(request, RequestOptions.DEFAULT);
    } catch (ElasticsearchException e) {
        if (e.status() == RestStatus.CONFLICT) {
        }
    }
}