Elasticsearch初步学习（仿京东搜索、爬虫）

ゝ一世哀愁。 2022-10-05 14:56 192阅读 0赞

[个人博客][Link 1]欢迎访问

> 微信搜索**程序dunk**，关注公众号，获取项目、博客源码

> 我们面前无所不有，我们面前一无所有 ——查尔斯·狄更斯

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>内容</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td><a href="https://blog.csdn.net/qq_45796208/article/details/117855794" rel="nofollow">Java基础面试题</a></td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td><a href="https://blog.csdn.net/qq_45796208/article/details/117531920?spm=1001.2014.3001.5501" rel="nofollow">JVM面试题</a></td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td><a href="https://blog.csdn.net/qq_45796208/article/details/116117767?spm=1001.2014.3001.5501" rel="nofollow">Java并发编程面试</a></td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td><a href="https://blog.csdn.net/qq_45796208/article/details/117070240?spm=1001.2014.3001.5501" rel="nofollow">计算机网络知识点汇总</a></td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td><a href="https://blog.csdn.net/qq_45796208/article/details/116856737?spm=1001.2014.3001.5501" rel="nofollow">MySQL面试题</a></td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td><a href="https://blog.csdn.net/qq_45796208/article/details/117155857?spm=1001.2014.3001.5501" rel="nofollow">Mybatis源码分析 + 面试</a></td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>Spring面试题</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>SpringMVC面试题</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td>SpringBoot面试题</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td><a href="https://blog.csdn.net/qq_45796208/article/details/117355798?spm=1001.2014.3001.5501" rel="nofollow">SpringCloud面试题</a></td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td><a href="https://blog.csdn.net/qq_45796208/article/details/116856194?spm=1001.2014.3001.5501" rel="nofollow">Redis面试题</a></td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td><a href="https://blog.csdn.net/qq_45796208/article/details/117754361?spm=1001.2014.3001.5501" rel="nofollow">Elasticsearch面试题</a></td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td>Docker学习</td> 
  </tr> 
  <tr> 
   <td>14</td> 
   <td>消息队列</td> 
  </tr> 
  <tr> 
   <td>15</td> 
   <td>持续更新…</td> 
  </tr> 
 </tbody> 
</table>

### 目录 ###

*  大数据背景介绍
 *  搜索引擎发展史
 *   *  搜索引擎分类
 *  Elasticsearch
 *   *  简介
     *   *  Lucene和Elasticsearch的关系
         *  使用场景
         *  Elasticsearch和Solr的区别
     *  REST是什么
     *   *  REST的关键原则
         *   *  Resource
             *  超文本驱动
             *  统一接口
             *  资源表述
             *  状态转移
     *  搜索技术基本知识
     *   *  数据搜索方式
         *  搜索引擎的工作原理
         *  网络爬虫工作原理
         *  网页分析
         *  倒排索引
         *   *  正向索引
             *  倒排索引
     *  安装
     *   *  ElasticSearch下载
         *  安装\[elasticsearch-head-master\](https://github.com/mobz/elasticsearch-head/archive/refs/heads/master.zip)
         *  启动elasticsearch-head-master
         *  开启跨域配置
         *  访问9200端口
         *  安装\[Kibana\](https://www.elastic.co/cn/kibana)
         *  汉化插件
     *  ES核心概念
     *   *  物理设计
         *  逻辑分页
         *   *  文档
             *  类型
             *  索引
             *  物理设计:节点和分片如何工作
     *  ELK简介
 *  IK分词器
 *   *  安装
     *  什么是分词器
     *  扩展字典
     *  索引的操作
     *   *  单纯创建索引
         *  修改索引的值
         *  删除索引
         *  查询
         *  复杂搜索
         *   *  匹配查询
             *  结果过滤
             *  排序
             *  分页
             *  布尔值查询
             *  过滤条件
             *  精确查询
             *  高亮查询
 *  SpringBoot集成ElasticSearch
 *   *  创建SpringBoot项目
     *  索引操作
     *  文档操作
     *  网络爬虫爬取jd数据
     *   *  引入jsoup依赖（注意版本问题）
         *  封装商品
         *  编写工具类
 *  仿京东搜索实战
 *   *  解析数据放入es中
     *   *  service层
         *  controller层
         *  页面展示
     *  从es中获取数据，渲染页面
     *   *  service层
         *  controller层
         *  页面展示
     *  添加页面高亮
     *   *  页面展示
 *  ElasticSearch面试题
 *   *  为什么要使用Elasticsearch？
     *  Elasticsearch写数据的过程？
     *  elasticsearch 的倒排索引是什么?
     *  elasticsearch 索引数据多了怎么办，如何调优，部署
     *   *  动态索引层面
         *  存储层面
         *  部署层面

# 大数据背景介绍 #

Lucene作者 Doug Cutting

[深入浅出大数据：到底什么是Hadoop？][Hadoop]

[Hadoop之父：Doug Cutting][Hadoop_Doug Cutting]

[elasticsearch中文社区][elasticsearch]

# 搜索引擎发展史 #

正如查尔斯·狄更斯在《双城记》中所述，在信息爆炸的当下，我们面前无所不有；而个人信息过载已经成为越来越多的人的负担，我们面前一无所有

如何摆脱过载的信息束缚，高效地找到自己需要的信息呢？——答案就是搜索引擎，借助搜索引擎实现

## 搜索引擎分类 ##

宏观而言，搜索引擎的发展经历了五个阶段和两大类

> 五个阶段

*  FTP文件检索阶段：搜索引擎会告诉用户从哪一个FTP地址可以下载被搜索的文件，代表作：Archie
 *  分类目录导航阶段：该阶段的搜索引擎就是一个导航网站，网站中都是网址分类陈列，用户在互联网上常用的网址在这里一应俱全，我们常用的好123、搜狗浏览器主页、UC导航等都是这类导航页面
 *  文本相关性检索阶段：引入了全文搜索技术，来保证搜索引擎检索到的网页标题和网页内容强一致，摒弃了单纯依赖网页标题和网页地址来判断网页内容的方法，代表作是Alta Vista、Excite等
 *  网页链接分析阶段：
    
     *  这个阶段的搜索引擎所使用的网站链接形式与当前基本相同，在该阶段，外部链接表示推荐
     *  因此通过计算每个网站的推荐链接数量，就可以判断一个网站的流行性和重要性
     *  于是，搜索引擎通过结合网页内容的重要性和相似度来改善搜索的信息质量
     *  代表作：Google
 *  用户意图识别阶段
    
     *  以用户为中心作为设计的初心，搜索引擎力求理解每一位用户的真正搜索诉求，力求千人千面，追求个性化识别和反馈
     *  比如输入”小米“，想要一个小米电子产品的用户和一个想要购买小米视频的用户，他们的搜索结果不同

> 两大类

*  站内搜索：
    
     *  近几年发展比较迅猛，各大网站平台纷纷上线了转内搜索，如SNS平台中的微博、人人网等，如电商平台中的京东、淘宝等
     *  另外，区块链内容搜索是近两年新的站内搜索形式，比如比特币区块链的搜索内容在比特币公链上，但比特币共公链的节点所在的区域却是分布式的
 *  站外搜索：全网搜索，如谷歌、百度等等

# Elasticsearch #

## 简介 ##

*  Elasticsearch是一个分布式、高扩展、高实时的搜索与[数据分析][Link 2]引擎。
 *  Elasticsearch提供了搜集、分析、存储数据三大功能，其主要特点有：分布式、零配置、易装易用、自动发现、索引自动分片、索引副本机制、RESTful风格接口、多数据源和自动搜索负载
 *  Elasticsearch并非从零起步，而是站在巨人的肩膀上。Elasticsearch基于Java编写，其内部使用Lucene做索引与搜索。通过进一步封装Lucene，向开放人员屏蔽了Lucene的复杂性只需要使用一套简单一致的RESTfulAPI即可。
 *  除此之外，Elasticsearch还解决了检索相关数据、返回统计结果、响应速度等相关问题，因此Elasticsearch能做到分布式环境下的实时文档存储和实时分析搜索。实时存储文档，每个字段都可以被索引与搜索
 *  Elasticsearch能都胜任成百上千个服务节点的分布式扩展，支持PB级别结构化或者非结构化海量数据的处理
 *  7.0版本中引入内存断路器、引入Elasticsearch的全新集群协调层——Zen2、支持更快的前k个查询、引入Function score2.0等，提高了可用性、性能和用户体验，使Elasticsearch变得更快、更安全、更易于使用

### Lucene和Elasticsearch的关系 ###

*  Lucene是一个免费、开源、高兴能、纯java编写的全文搜索引擎
 *  Lucene是Apache的顶级项目
 *  ElasticSearch 和 Solr 都是基于 Lucene 的搜索引擎，是对 Lucene 的封装，Lucene仅仅是一个工具包，它并非一个完整的全文搜索引擎，这个Lucene的初衷有关，Lucene主要问软件开发人员提供一个简单易用的工具包，主要提供**倒排索引**的查询，以便软件开发人员在其业务系统中实现全文搜索功能

### 使用场景 ###

站内搜索，用户行为，社交数据，异常讨论，开源代码，电商商品，日志分析，价格监控，商业智能等等

### Elasticsearch和Solr的区别 ###

*  当单纯的对已有数据进行搜索时，Solr 更快
 *  当实时建立索引时，Solr 会产生 io 阻塞，查询性能较差，ElasticSearch 具有明显的优势
 *  随着数据量的增加，Solr 的搜索效率会变得更低，而 ElasticSearch 却没有明显的变化
 *  转变搜索基础设施后从 Solr 到 ElasticSearch 可以大幅度提高搜索性能
 *  ElasticSearch 开箱即用，Solr 需要安装
 *  Solr 利用 Zookeeper 进行分布式管理，而 ElasticSearch 自身带有分布式协调管理功能
 *  Solr 支持更多格式的数据，例如 JSON、XML、CSV，而 ElasticSearch 仅支持 JSON 文件格式
 *  Solr 官方提供的功能更多，而 ElasticSearch 本身更注重于核心功能，高级功能多由第三方插件提供，例如图形化界面需要 kibana 友好支撑
 *  Solr 查询快，但更新索引时慢，用于电商等查询多的应用。ElasticSearch 建立索引快即实时性查询快，用于 facebook、新浪等搜索应用
 *  Solr 是传统搜索应用的有力解决方案，ElasticSearch 更适用于新兴的实时搜索应用

## REST是什么 ##

REST的英文是Representational State Transfer，中文翻译”表述性状态转移“，一种软件架构风格、设计风格，而不是标准，只是提供了一组设计原则和约束条件，是所有Web应用都应该遵守的架构设计指导原则。它主要用于客户端和服务器交互类的软件。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

### REST的关键原则 ###

*  Resource（资源）：表示为所有事务定义ID
 *  Hypertext Driver（超文本驱动）：表示所有事物链接在一起
 *  Uniform Interface（统一接口）：表示使用标准的方法
 *  Representation（资源的表述）：表示资源多重表述的方法
 *  State Transfer（状态转移）：表示无状态通信

#### Resource ####

> 资源其实可以看做一种看待服务器的方式

*  一个资源可以由一个或者多个URI来标识。URI既是资源的名称，也是资源在Web上的地址，对某个资源感兴趣的客户端，可以通过资源的URI与其进行交互访问并获取
 *  将服务器看做由很多离散的资源组成，资源可以是一文件系统的一个文件，也可以是数据库中的一张表
 *  资源意味着为所有事务定义ID，在Web开发中，每个事务都是可被标志的，都会拥有一个ID，代表ID的统一概念是URI
    
     *  URI（Uniform Resource Identifier）：统一资源标识符，包括URL和URN
        
         *  URL（Uniform Resource Locator）：统一资源定位符，常见的有Web URL和FTP URL
         *  URN（Uniform Resource Name）：统一资源名称，例如：tel:+1-888-888-8888
 *  设计URI的四个原则
    
     *  它们是名词
     *  区分单复数
     *  URI有长度限制，建议小于1KB
     *  在URI中不要放未加密的敏感信息

#### 超文本驱动 ####

> 意味着所有事物链接在一起

*  核心就是超媒体，换句话说就是链接的思想
 *  引入链接后，Web应用可以看做一个有很多状态组成的有限状态机，资源之间通过超链接相互关联
 *  URI是全球表针，所以构成Web的所有资源都是可以相互连通的
 *  客户端可以通过链接将应用从一个状态转变为另一个状态

#### 统一接口 ####

> 统一接口意味着使用标准的方法

四个HTTP方法：POST、GET、PUT、DELETE

Elasticsearch中的Rest命令说明

<table> 
 <thead> 
  <tr> 
   <th>method</th> 
   <th>url地址</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>PUT</td> 
   <td>localhost:9200/index/type/documentId</td> 
   <td>创建文档（指定文档id）</td> 
  </tr> 
  <tr> 
   <td>POST</td> 
   <td>localhost:9200/index/type/</td> 
   <td>创建文档（随机文档id）</td> 
  </tr> 
  <tr> 
   <td>POST</td> 
   <td>localhost:9200/index/type/documentId/_update</td> 
   <td>修改文档</td> 
  </tr> 
  <tr> 
   <td>DELETE</td> 
   <td>localhost:9200/index/type/documentId</td> 
   <td>删除文档</td> 
  </tr> 
  <tr> 
   <td>GET</td> 
   <td>localhost:9200/index/type/documentId</td> 
   <td>查询文档通过文档id</td> 
  </tr> 
  <tr> 
   <td>POST</td> 
   <td>localhost:9200/index/type/_search</td> 
   <td>查询所有数据</td> 
  </tr> 
 </tbody> 
</table>

#### 资源表述 ####

> 资源的表示是对一段资源在某个特定时刻的状态的描述。资源可以在客户端——服务器之间传递

资源的表述有很多格式：HTML、XML、JSON、文本、图片、音频、视频等

#### 状态转移 ####

> 意味着无状态通信

无状态即服务器的变化 对客户端是不可见的，主要为了保证架构设计的可伸缩性和可扩展

## 搜索技术基本知识 ##

### 数据搜索方式 ###

> 搜索引擎主要是对数据进行检索。而研发过程中不难发现，数据有两种类型，即结构化数据和非结构化数据

*  结构化
    
     *  结构化数据：结构化数据一般我们会放入关系性数据库如MySQL和Oracle等，这是因为结构化数据有固定的数据格式和有限个数的字段，因此通过二维化的表结构来承载
     *  结构化搜索：因为关系型数据库往往支持索引，因此结构化数据可以通过关系型数据库来完成搜索和查找，常用的方式有顺序扫描、关键字精确匹配等，对于复杂的关键字匹配可以使用like关键字匹配
 *  非结构化
    
     *  非结构化数据：非结构化数据一般会放入MongoDB中，这是因为非结构化数据的数据长度不定且无固定数据格式
     *  非结构化搜索：对于非结构化数据而言，顺序扫描是效率很低的方法，因此引入全文搜索技术
     *  全文搜索过程中，一般需要提取非结构化数据中的有效信息，重新组织数据的承载结构形式，而检索数据时，需要基于新结构化数据展开，从而达到提高搜索速度的目的（空间换时间的做法）

### 搜索引擎的工作原理 ###

> 搜索引擎的工作原理

![image-20210607172424779][]

搜索引擎的工作原理分为两个阶段

*  网页数据爬取和索引阶段
    
     *  网络爬虫用于爬取互联网上的网页，爬取到一个新的网页后继续通过该页面中的链接爬取其他网页
     *  网页被网络爬虫爬取后，会被存入网页库，以备进行数据预处理，因为页面有一定的重复性，所以在把新的网页插入网页库之前需要查重
     *  预处理不断地从网页中取出网页进行必要的预处理，取出噪声内容（广告、导航条、声明文字）、关键词处理、网页链接关系计算等，此外，网页上还有文件文档（PDF、WORD、WPS等）、多媒体文件等，都需要预处理
     *  预处理后，要进行索引过程，索引过程先后经历正向索引和倒排索引阶段，最终简历索引库，随着不断的加入网页库，索引库的更新和维护往往也是增量进行的
 *  搜索阶段
    
     *  用户输入的关键字同样会经过预处理，如删除不必要的标点符号、停用词、空格等
     *  然后从索引库中查询需要的内容进行排序，返回给用户

### 网络爬虫工作原理 ###

> 网络爬虫有多个不同称谓，如网络探测器、Spider蜘蛛等，取意的原因是网页爬取程序像虫子一样在网络间爬来爬取，从一个网页链接爬到另一个网页链接

*  网络爬虫用于爬取互联网上的网页，爬取到一个新的网页后继续通过该页面中的链接爬取其他网页，如此循环，直到所有的内容都被爬取完
 *  为了提高效率，一般采用并行爬取的方式，多个网络爬虫在并行爬取过程中，不重复的爬取一个网页尤为重要

![image-20210607174301357][]

*  网页爬取的方式
    
     *  先深度后广度（一般采用）
     *  先广度后深度
 *  收录模式
    
     *  增量收集：搜索新的网页，搜集更新，不覆盖，设计复杂、时效性好
     *  全量收集：更新全部数据，开销大、成本高、时效性不高、网路带宽消耗大、耗时比较长，一般都是定期展开

> 我们可以基于现有的爬虫框架来实现对网络数据的爬取，java语言技术栈可以使用WebMagic、Gecco；Python语言栈使用Scrapy；GO语言使用YiSpider

### 网页分析 ###

在搜索引擎中，爬虫爬取了对应的网页之后，会将网页存储到服务器的原始数据库中，之后，搜索引擎会对这些网页进行分析并确定各网页的重要性，即会影响用户检索的排名结果

所以在此，我们需要对搜索引擎的网页分析算法进行简单了解

搜索引擎的网页分析算法主要分为3类：基于用户行为的网页分析算法、基于网络拓扑的网页分析算法、基于网页内容的网页分析算法

*  基于用户行为的网页分析算法：基于用户行为的网页分析算法是比较好理解的。这种算法中，会依据用户对这些网页的访问行为，对这些网页进行评价，比如，依据用户对该网页的访问频率、用户对网页的访问时长、用户的单击率等信息对网页进行综合评价
 *  基于网络拓扑的网页分析算法：基于网络拓扑的网页分析算法是依靠网页的链接关系、结构关系、已知网页或数据等对网页进行分析的一种算法，所谓拓扑，简单来说即结构关系的意思
    
     *  基于网页粒度的分析算法
     *  基于网页块粒度的分析算法
     *  基于网站粒度的分析算法
        
         *  PageRank算法是一种比较典型的基于网页粒度的分析算法。相信很多朋友都听过Page-Rank算法，它是谷歌搜索引擎的核心算法，简单来说，它会根据网页之间的链接关系对网页的权重进行计算，并可以依靠这些计算出来的权重，对网页进行排名
 *  基于网页内容的网页分析算法：在基于网页内容的网页分析算法中，会依据网页的数据、文本等网页内容特征，对网页进行相应的评价

### [倒排索引][Link 3] ###

#### 正向索引 ####

在**搜索引擎**中每个文件都对应一个文件ID，文件内容被表示为一系列关键词的集合（实际上在搜索引擎索引库中，关键词也已经转换为关键词ID）。例如“文档1”经过分词，提取了20个关键词，每个关键词都会记录它在文档中的出现次数和出现位置。

正向索引的结构

![image-20210607180101180][]

> 一般是通过key，去找value。

#### 倒排索引 ####

所以，搜索引擎会将正向索引重新构建为倒排索引，即把文件ID对应到关键词的映射转换为关键词到文件ID的映射，每个关键词都对应着一系列的文件，这些文件中都出现这个关键词。

得到**倒排索引**的结构如下：

![image-20210607180222816][]

基于词做索引明显比基于字做索引内容要少的多，因而查询会更高效（所以引入了中文分词器（ik分词器））

倒排序中三个名词

*  词条（Term）：索引里面最小的存储单元和查询单元，英文环境就是一个单词，中文环境词条指的是分词后的一个词组
 *  字典（Term Dictionary）：词条的集合，一般由网页或者文章集合中出现过的所有词构成的字符串集合
 *  倒序表（Post List）：记录词出现在那些文档里、出现的位置和频率等，如下图

![image-20210606165856483][]

## 安装 ##

### [ElasticSearch下载][ElasticSearch] ###

熟悉目录

1.  `bin`: 启动文件
2.  `config`: 配置文件
3.  `log4j`: 日志文件
4.  `jvm.options`: java 虚拟机先关的配置
5.  `elasticsearch.xml`: elasticsearch 的配置文件
6.  `lib`: 相关 jar 包
7.  `logs`: 日志
8.  `modules`: 功能模块
9.  `plugins`: 插件 ik

### 安装[elasticsearch-head-master][] ###

### 启动elasticsearch-head-master ###

cnpm install
    npm run start

### 开启跨域配置 ###

`\elasticsearch-7.13.1\config\elasticsearch.yml`

#开启http跨域
    http.cors.enabled: true
    #允许所有人可以访问
    http.cors.allow-origin: "*"

### 访问9200端口 ###

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FoZteADV-1623243865535)(https://gitee.com/zhang-songyao/blog-images/raw/master/20210606145636.png)\]

### 安装[Kibana][] ###

### 汉化插件 ###

\\kibana-7.13.1-windows-x86\_64\\config\\kibana.yml

i18n.locale: "zh-CN"

![image-20210607181057441][]

## ES核心概念 ##

ElasticSearch是面向文档的，关系型数据库和ElasticSearch客观对比

<table> 
 <thead> 
  <tr> 
   <th>Relational DB</th> 
   <th>ElasticSearch</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>数据库(Database)</td> 
   <td>索引(index)</td> 
  </tr> 
  <tr> 
   <td>表(table)</td> 
   <td>types（慢慢废弃）</td> 
  </tr> 
  <tr> 
   <td>行(rows)</td> 
   <td>文档(documents)</td> 
  </tr> 
  <tr> 
   <td>字段(columns)</td> 
   <td>fields</td> 
  </tr> 
 </tbody> 
</table>

ElasticSearch集群中可以包含多个索引（数据库），每个索引可以包含多个类型（表），每个类型下可以包含多个文档（行），每个文档中可以包含多个字段（列）

### 物理设计 ###

ElasticSearch在后台吧多个所以划分成多个分片，每个分片可以在集群中的不同服务器迁移

### 逻辑分页 ###

一个类型中,包含多个文档,比如说文档1,文档2,当我们索引一篇文档时,可以通过这样的顺序找到它:索引>类型>文档ID,通过这个组合我们就能索引到某个具体的文档。注意:ID不必是整数,实际上它是个字符串

#### 文档 ####

文档(Document)：一般搜索引擎的处理对象是互联网网页，而文档这个概念要更宽泛些，代表以文本形式存在的存储对象，相比网页来说，涵盖更多种形式，比如Word，PDF，html，XML等不同格式的文件都可以称之为文档。再比如一封邮件，一条短信，一条微博也可以称之为文档。在本书后续内容，很多情况下会使用文档来表征文本信息

ElasticSearch中，文档有几个重要属性：

*  自我包含,一篇文档同时包含字段和对应的值,也就是同时包含keyvalue!
 *  可以是层次型的,一个文档中包含自文档,复杂的逻辑实体就是这么来的!（就是一个JSON对象，FastJson进行转换!）
 *  灵活的结构,文档不依赖预先定义的模式,我们知道关系型数据库中,要提前定义字段才能使用,在elasticsearch中,对于字段是非常灵活的,有时候,我们可以忽略该字段,或者动态的添加一个新的字段。

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

#### 类型 ####

类型是文档的逻辑容器,就像关系型数据库一样,表格是行的容器。类型中对于字段的定义称为映射,比如name映射为字符串类型。我们说文档是无模式的,它们不需要拥有映射中所定义的所有字段,比如新增一个字段,那么 ElasticSearch是怎么做的呢?  
ElasticSearch会自动的将新字段加入映射,但是这个字段的不确定它是什么类型, ElasticSearch就开始猜,如果这个值是18,那么ElasticSearch会认为它是整形,但是 ElasticSearch也可能猜不对,所以最安全的方式就是提前定义好所需要的映射,这点跟关系型数据库殊途同归了,先定义好字段,然后再使用

#### 索引 ####

就是数据库

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

#### 物理设计:节点和分片如何工作 ####

一个集群至少有一个节点,而一个节点就是一个 ElasticSearch进程,节点可以有多个索引默认的,如果你创建索引,那么索引将会有个5个分片( primary shard又称主分片)构成的,每个主分片会有一个副本( replica shard,又称复制分片)

主分片和对应的复制分片都不会在同一个节点内,这样有利于某个节点挂掉了,数据也不至于丢失。实际上,一个分片是一个 Lucene索引,一个包含**倒排索引**的文件目录,倒排索引的结构使得 ElasticSearch在不扫描全部文档的情况下,就能告诉你哪些文档包含特定的关键字

## ELK简介 ##

ELK是三个开源软件的缩写，分别表示：Elasticsearch , Logstash, Kibana , 它们都是开源软件。新增了一个FileBeat，它是一个轻量级的日志收集处理工具(Agent)，Filebeat占用资源少，适合于在各个服务器上搜集日志后传输给Logstash，官方也推荐此工具。

Elasticsearch是个开源分布式搜索引擎，提供搜集、分析、存储数据三大功能。它的特点有：分布式，零配置，自动发现，索引自动分片，索引副本机制，restful风格接口，多数据源，自动搜索负载等。

Logstash 主要是用来日志的搜集、分析、过滤日志的工具，支持大量的数据获取方式。一般工作方式为c/s架构，client端安装在需要收集日志的主机上，server端负责将收到的各节点日志进行过滤、修改等操作在一并发往elasticsearch上去。

Kibana 也是一个开源和免费的工具，Kibana可以为 Logstash 和 ElasticSearch 提供的日志分析友好的 Web 界面，可以帮助汇总、分析和搜索重要数据日志。

Filebeat隶属于Beats。目前Beats包含四种工具：

1.  Packetbeat（搜集网络流量数据）
2.  Topbeat（搜集系统、进程和文件系统级别的 CPU 和内存使用情况等数据）
3.  Filebeat（搜集文件数据）
4.  Winlogbeat（搜集 Windows 事件日志数据）

# IK分词器 #

## 安装 ##

[下载IK分词器][IK]

> 注意版本一定要和ElasticSearch版本一致！！！！

解压放在`\elasticsearch-7.13.1\plugins\ik`目录下，注意是编译打包过得文件

重启ElasticSearch，插件加载完毕

![image-20210606181727878][]

通过elasticsearch-plugin插件查看加载的插件

![image-20210606182122961][]

## 什么是分词器 ##

分词：即把一段中文或者别的划分成一个个的关键字,我们在搜索时候会把自己的信息进行分词,会把数据库中或者索引库中的数据进行分词,然后进行一个匹配操作,默认的中文分词是将每个字看成一个词,比如”我爱长安”会被分为”我”、”爱”、”长”、”安”、这显然是不符合要求的,所以我们需要安装中文分词器来解决这个问题

iK提供了两个分词算法: ik\_smart（最小分词器）和 ik\_max\_word（最细粒度划分）,其中 ik\_smart为最少切分, ik\_max\_word为最细粒度划分

## 扩展字典 ##

使用分词器查询`程序dunk`可以看到

GET _analyze 
    { 
        "analyzer" : "ik_max_word",
        "text" : "程序dunk"
    }

![image-20210606195047352][]

如果想要吧程序dunk当做一个词语，那么需要在`elasticsearch-7.13.1\plugins\ik\config`路径下自己扩展字典

![image-20210606195444729][]

重启服务，可以看到分词器，将程序dunk单独划分了出来

![image-20210606200356058][]

## 索引的操作 ##

> 添加索引、同时添加数据

PUT test1/type1/1
    { 
        "name" : "dunk_code",
        "age" : 18
    }

### 单纯创建索引 ###

PUT test2
    { 
      "mappings": { 
        "properties": { 
          "name" : { 
            "type": "text"
          },
          "age" : { 
            "type": "long"
          },
          "birthday" : { 
            "type": "date"
          }
        }
      }
    }

### 修改索引的值 ###

POST /test1/type1/1/_update
    { 
      "doc" : { 
        "name" : "程序dunk"
      }
    }

### 删除索引 ###

DELETE test1/type1/1

### 查询 ###

//查询该索引的信息
    GET test1/
    //查询索引下指定文档id信息
    GET test1/type1/1
    //精确查询name为dunk_code的信息
    GET test1/type1/_search?q=name : dunk_code

### 复杂搜索 ###

创建索引

PUT /xauat/student/1 
    { 
      "name" : "程序dunk",
      "age" : 21,
      "desc" : "必进大厂",
      "tags" : ["编程", "篮球", "游戏"]
    }

#### 匹配查询 ####

> \_query

GET /xauat/student/_search
    { 
      "query" : { 
        "match": { 
          "name" : "程序"
        }
      }
    }

#### 结果过滤 ####

> \_source：保留那些数据

"_source" : ["name","desc"]

#### 排序 ####

> sort

"sort" : [
        { 
          "age" : { 
            "order" : "asc"
          }
        }
      ]

#### 分页 ####

> from ：开始页
> 
> size：页码

"from" : 0,
    "size" : 2

#### 布尔值查询 ####

> must ： and

GET /xauat/student/_search
    { 
      "query" : { 
        "bool": { 
          "must": [
            { 
              "match" : { 
                "name" : "dunk"
              }
            },
            { 
              "match": { 
                "age" : 30
              }
            }
            
          ]
        }
      }
    }

> should：or

GET /xauat/student/_search
    { 
      "query" : { 
        "bool": { 
          "should": [
            { 
              "match" : { 
                "name" : "dunk"
              }
            },
            { 
              "match": { 
                "age" : 30
              }
            }
            
          ]
        }
      }
    }

> must\_not：not

#### 过滤条件 ####

> filter

GET /xauat/student/_search
    { 
      "query" : { 
        "bool": { 
          "must": [
            { 
              "match" : { 
                "name" : "dunk"
              }
            }
          ],
          "filter": { 
            "range" : { 
              "age" : { 
                "gte" : 21,
                "lte" : 30
              }
            }
          }
        }
      }
    }

*  gt：大于
 *  gte：大于等于
 *  lt：小于
 *  lte：小于等于
 *  eq：相等

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

term 查询是直接通过倒排索引指定的词条进行精确查找！

**关于分词：**

*  term：直接查询精确的
 *  match : 会使用分词器解析

**两个类型 text keyword**

*  text 会被分词器解析
 *  keyword 不会被分词器解析

#### 高亮查询 ####

> 高亮：highlight
> 
> 前缀：pre\_tags
> 
> 后缀：post\_tags

GET /xauat/student/_search
    { 
      "query" : { 
        "term": { 
          "name" : "dunk"
        }
      },
      "highlight" : { 
        "pre_tags": "<p class='key' style='color:red'>", 
        "post_tags": "</p>", 
        "fields": { 
          "name" : { }
        }
      }
    }

# SpringBoot集成ElasticSearch #

## 创建SpringBoot项目 ##

导入SpringData Elasticsearch依赖

![image-20210608104025028][]

## 索引操作 ##

@Test
    //创建索引
    void testCreateIndex() throws IOException { 
        CreateIndexRequest request = new CreateIndexRequest("xauat");
        client.indices().create(request, RequestOptions.DEFAULT);
    }
    @Test
    //判断是否存在索引
    void isExistIndex() throws IOException { 
        GetIndexRequest request = new GetIndexRequest("xauat");
        boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
        System.out.println(exists);
    }
    @Test
    //删除索引
    void deleteIndex() throws IOException { 
        DeleteIndexRequest request = new DeleteIndexRequest("xauat");
        AcknowledgedResponse delete = client.indices().delete(request, RequestOptions.DEFAULT);
        System.out.println(delete.isAcknowledged());
    }

## 文档操作 ##

@Test
    //创建文档
    void createDocument() throws IOException { 
        //创建请求
        IndexRequest request = new IndexRequest("xauat");
        //创建对象
        Student student = new Student("王五",
                40, "编程大佬", Arrays.asList("编程", "学习"));
        //设置请求
        request.id("6");
        request.timeout(TimeValue.timeValueMillis(1));
        //将数据转为json格式放入请求
        request.source(JSON.toJSONString(student), XContentType.JSON);
        //发送请求
        IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);
        //获取响应结果
        System.out.println(indexResponse.toString());
        //响应状态
        System.out.println(indexResponse.status());
    }
    @Test
    //获取文档
    void getDocument() throws IOException { 
        GetRequest request = new GetRequest("xauat", "6");
        //判断是否存在
        boolean exists = client.exists(request, RequestOptions.DEFAULT);
        System.out.println(exists);
        GetResponse getResponse = client.get(request, RequestOptions.DEFAULT);
        //返回全部内容
        System.out.println(getResponse);
        //打印文档内容
        System.out.println(getResponse.getSourceAsString());
    }
    @Test
    //更新文档
    void updateDocument() throws IOException { 
        UpdateRequest request = new UpdateRequest("xauat", "6");
        Student student = new Student("王五",
                40, "编程菜鸡", Arrays.asList("编程", "互啄"));
        request.doc(JSON.toJSONString(student), XContentType.JSON);
        UpdateResponse update = client.update(request, RequestOptions.DEFAULT);
        System.out.println(update.status());
    }
    @Test
    //删除文档
    void DeleteDocument() throws IOException { 
        DeleteRequest request = new DeleteRequest("xauat", "3");
        DeleteResponse delete = client.delete(request, RequestOptions.DEFAULT);
        System.out.println(delete.status());
    }
    @Test
    //批量插入
    void  addBatch() throws IOException { 
        List<Student> students = new ArrayList<>();
        //创建请求
        BulkRequest bulkRequest = new BulkRequest();
        students.add(new Student("王五",
                40, "编程菜鸡", Arrays.asList("编程", "互啄")));
        students.add(new Student("王五",
                40, "编程菜鸡", Arrays.asList("编程", "互啄")));
        students.add(new Student("王五",
                40, "编程菜鸡", Arrays.asList("编程", "互啄")));
        students.add(new Student("王五",
                40, "编程菜鸡", Arrays.asList("编程", "互啄")));
        for (int i = 0; i < students.size(); i++) { 
            bulkRequest.add(new IndexRequest("xauat")
                    .id(i + 6 + "")
                    .source(JSON.toJSONString(students.get(i)), XContentType.JSON));
            BulkResponse bulk = client.bulk(bulkRequest, RequestOptions.DEFAULT);
            System.out.println(bulk.status());
        }
    }
    @Test
    //查询
    void SearchDocument() throws IOException { 
        SearchRequest request = new SearchRequest();
        //构建搜素条件
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //构建查询条件
        TermQueryBuilder termQueryBuilder = new TermQueryBuilder("name", "dunk");
        searchSourceBuilder.query(termQueryBuilder);
        searchSourceBuilder.timeout(TimeValue.timeValueMillis(2000));
        request.source(searchSourceBuilder);
        SearchResponse search = client.search(request, RequestOptions.DEFAULT);
        //查询结果集
        SearchHits hits = search.getHits();
        System.out.println(JSON.toJSONString(hits));
        //循环打印每个查询结果
        for (SearchHit hit : hits.getHits()) { 
            System.out.println(hit.getSourceAsMap());
        }
        
    }

## 网络爬虫爬取jd数据 ##

### 引入jsoup依赖（注意版本问题） ###

<dependency>
        <groupId>org.jsoup</groupId>
        <artifactId>jsoup</artifactId>
        <version>1.13.1</version>
    </dependency>

### 封装商品 ###

/** * @author ：zsy * @date ：Created 2021/6/9 16:17 * @description：商品 */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @ToString
    public class Content { 
        private String img;
        private String price;
        private String name;
    }

### 编写工具类 ###

> jd图片是懒加载的，所以从`"data-lazy-img"`中获取图片url而不是src

/** * @author ：zsy * @date ：Created 2021/6/9 15:24 * @description：解析网页 */
    public class HtmlParseUtil { 
        public static void main(String[] args) throws IOException { 
            HtmlParseUtil.parseJD("java").forEach(System.out::println);
        }
        public static List<Content> parseJD(String keyWord) throws IOException { 
            String url = "https://search.jd.com/Search?keyword=" + keyWord;
            Document document = Jsoup.parse(new URL(url), 30000);
            Element e = document.getElementById("J_goodsList");
            //System.out.println(e.html());
            List<Content> list = new ArrayList<>();
            Elements lis = e.getElementsByTag("li");
            for (Element li : lis) { 
                //所有图片都是延时加载的
                String img = li.getElementsByTag("img").eq(0).attr("data-lazy-img");
                String price = li.getElementsByClass("p-price").eq(0).text();
                String name = li.getElementsByClass("p-name").eq(0).text();
                //System.out.println("http:" + img);
                //System.out.println(price);
                //System.out.println(name);
                list.add(new Content("http:" + img, price, name));
            }
            return list;
        }
    }

# 仿京东搜索实战 #

前端页面如下

![image-20210609195403771][]

## 解析数据放入es中 ##

### service层 ###

/** * @author ：zsy * @date ：Created 2021/6/9 16:45 * @description：jd搜索 */
    public interface JDService { 
    
        //解析数据放入es
        Boolean analyticalData(String keyword) throws IOException;
    }
    
    /** * @author ：zsy * @date ：Created 2021/6/9 16:45 * @description：实现 */
    @Service
    public class JDServiceImpl implements JDService { 
    
        @Autowired
        RestHighLevelClient client;
    
        @Override
        public Boolean analyticalData(String keyword) throws IOException { 
            //获取解析数据
            List<Content> contents = HtmlParseUtil.parseJD(keyword);
    
            //判断索引是否存在
            GetIndexRequest getRequest = new GetIndexRequest("jd_goods");
            boolean exists = client.indices().exists(getRequest, RequestOptions.DEFAULT);
            if (!exists) { 
                //索引不存在，创建索引
                CreateIndexRequest createIndexRequest = new CreateIndexRequest("jd_goods");
                CreateIndexResponse createIndexResponse = client.indices().create(createIndexRequest, RequestOptions.DEFAULT);
                if (!createIndexResponse.isAcknowledged()) return false;
            }
            //批处理请求
            BulkRequest bulkRequest = new BulkRequest();
            for (int i = 0; i < contents.size(); i++) { 
                bulkRequest.add(new IndexRequest("jd_goods")
                        .source(JSON.toJSONString(contents.get(i)), XContentType.JSON));
            }
            bulkRequest.timeout(TimeValue.timeValueMillis(10000));
            BulkResponse searchResponse = client.bulk(bulkRequest, RequestOptions.DEFAULT);
    
            return !searchResponse.hasFailures();
        }
    
    }

### controller层 ###

/** * @author ：zsy * @date ：Created 2021/6/9 17:40 * @description：商品 */
    @Controller
    public class ContentController { 
    
        @Autowired
        JDService jdService;
    
        @GetMapping("/parse/{keyword}")
        @ResponseBody
        public Boolean parse(@PathVariable String keyword) throws IOException { 
            return jdService.analyticalData(keyword);
        }
    }

### 页面展示 ###

![image-20210609200132756][]

## 从es中获取数据，渲染页面 ##

### service层 ###

List<Map<String, Object>> search(String keyword, int pageNo, int pageSize) throws IOException;
    
    @Override
    public List<Map<String, Object>> search(String keyword, int pageNo, int pageSize) throws IOException { 
        SearchRequest searchRequest = new SearchRequest();
        List<Map<String, Object>> list = new ArrayList<>();
        //构建搜索条件
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //分页
        searchSourceBuilder.from(pageNo);
        searchSourceBuilder.size(pageSize);
        //精确匹配
        TermQueryBuilder termQueryBuilder = new TermQueryBuilder("name", keyword);
        searchSourceBuilder.query(termQueryBuilder);
        searchSourceBuilder.timeout(TimeValue.timeValueMillis(10000));
        //执行搜索
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
        //查询结果集
        SearchHits hits = searchResponse.getHits();
        for(SearchHit hit : hits) { 
            list.add(hit.getSourceAsMap());
        }
        return list;
    }

### controller层 ###

@ResponseBody
    @GetMapping("/search/{keyword}/{pageNo}/{pageSize}")
    public List<Map<String, Object>> search(
            @PathVariable String keyword,
            @PathVariable int pageNo,
            @PathVariable int pageSize) throws IOException { 
        return jdService.search(keyword, pageNo, pageSize);
    }

### 页面展示 ###

![image-20210609200023117][]

## 添加页面高亮 ##

@Override
    public List<Map<String, Object>> search(String keyword, int pageNo, int pageSize) throws IOException { 
        SearchRequest searchRequest = new SearchRequest();
        List<Map<String, Object>> list = new ArrayList<>();
        //构建搜索条件
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //分页
        searchSourceBuilder.from(pageNo);
        searchSourceBuilder.size(pageSize);
        //精确匹配
        TermQueryBuilder termQueryBuilder = new TermQueryBuilder("name", keyword);
        searchSourceBuilder.query(termQueryBuilder);
        searchSourceBuilder.timeout(TimeValue.timeValueMillis(10000));
        //添加高亮
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.field("name");
        highlightBuilder.requireFieldMatch(false);
        highlightBuilder.preTags("<span style='color:red'>");
        highlightBuilder.postTags("</span>");
        searchSourceBuilder.highlighter(highlightBuilder);
        //执行搜索
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
        //查询结果集
        SearchHits hits = searchResponse.getHits();
        for(SearchHit hit : hits) { 
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            //获取原来的结果
            HighlightField name = highlightFields.get("name");
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            if (name != null) { 
                Text[] fragments = name.fragments();
                String curName = "";
                for (Text fragment : fragments) { 
                    curName += fragment;
                }
                sourceAsMap.put("name", curName);
            }
            name = highlightFields.get("name");
            list.add(hit.getSourceAsMap());
        }
        return list;
    }

### 页面展示 ###

![image-20210609203151874][]

# [ElasticSearch面试题][ElasticSearch 1] #

## 为什么要使用Elasticsearch？ ##

系统中的数据，随着业务的发展，时间的推移，将会非常的多，而业务中往往采用模糊查询进行数据结构搜索，而模糊查询会导致查询引擎放弃索引，导致系统查询数据时都是全盘扫描，在百万级别数据库中，查询效率是非常低效的，而Es是一个全文索引，将经常查询的系统功能的某些字段，比如电商系统表中的商品名，描述、价格和id都可以放入ES索引库，提高查询效率

## Elasticsearch写数据的过程？ ##

> 文档写入包含：单文档写入和批量 bulk 写入，这里只解释一下：单文档写入流程

![img][]

*  客户写集群某节点写入数据，发送请求。（如果没有指定路由/协调节点，请求的节点扮演路由节点的角色
 *  节点 1 接受到请求后，使用文档\_id 来确定文档属于分片 0。请求会被转到另外的节点，假定节点 3。因此分片 0 的主分片分配到节点 3 上
 *  节点 3 在主分片上执行写操作，如果成功，则将请求并行转发到节点 1和节点 2 的副本分片上，等待结果返回。所有的副本分片都报告成功，节点 3 将向协调节点（节点 1）报告成功，节点 1 向请求客户端报告写入成功

第二步中的文档获取分片的过程

借助路由算法获取，路由算法就是根据路由和文档 id 计算目标的分片 id 的过程

## elasticsearch 的倒排索引是什么? ##

传统的我们的检索是通过文章，逐个遍历找到对应关键词的位置

而倒排索引，是通过分词策略，形成了词和文章的映射关系表，这种词典+映射表即为倒排索引。有了倒排索引，就能实现 o（1）时间复杂度的效率检索文章了，极大的提高了检索效率

倒排索引，相反于一篇文章包含了哪些词，它从词出发，记载了这个词在哪些文档中出现过，由两部分组成——词典和倒排表

> 加分项：倒排索引的底层实现是基于：FST（Finite State Transducer）数据结构

ucene 从 4+版本后开始大量使用的数据结构是 FST。FST 有两个优点：

*  空间占用小。通过对词典中单词前缀和后缀的重复利用，压缩了存储空间
 *  查询速度快。O(len(str))的查询时间复杂度

## elasticsearch 索引数据多了怎么办，如何调优，部署 ##

索引数据的规划，应在前期做好规划，正所谓“设计先行，编码在后”，这样才能有效的避免突如其来的数据激增导致集群处理能力不足引发的线上客户检索或者其他业务受到影响。

### 动态索引层面 ###

基于模板+时间+rollover api 滚动创建索引，举例：设计阶段定义：blog 索引的模板格式为：blog\_index\_时间戳的形式，每天递增数据。这样做的好处：不至于数据量激增导致单个索引数据量非常大，接近于上线 2 的32 次幂-1，索引存储达到了 TB+甚至更大。

一旦单个索引很大，存储等各种风险也随之而来，所以要提前考虑+及早避免。

### 存储层面 ###

冷热数据分离存储，热数据（比如最近 3 天或者一周的数据），其余为冷数据。

对于冷数据不会再写入新数据，可以考虑定期 force\_merge 加 shrink 压缩操作，节省存储空间和检索效率。

### 部署层面 ###

一旦之前没有规划，这里就属于应急策略。

结合 ES 自身的支持动态扩展的特点，动态新增机器的方式可以缓解集群压力，注意：如果之前主节点等规划合理，不需要重启集群也能完成动态新增的

参考文档：  
《Elasticsearch实战与原理解析》牛冬  
[ElasticSearch面试题][ElasticSearch 1]  
参考视频：  
[仿京东实战搜索][Link 4]

[Link 1]: http://www.dunkcode.cn/
[Hadoop]: https://mp.weixin.qq.com/s/cTJ_j1s2oUHPZEh1TdfFUg
[Hadoop_Doug Cutting]: https://www.jianshu.com/p/af2e09f32fcc
[elasticsearch]: https://elasticsearch.cn/
[Link 2]: https://baike.baidu.com/item/%E6%95%B0%E6%8D%AE%E5%88%86%E6%9E%90/6577123
[image-20210607172424779]: /images/20221005/5a5de7879e784cb3bb0f0bbac18b9f94.png
[image-20210607174301357]: /images/20221005/ff4fbe80c02b45d5976c1dcf9216c662.png
[Link 3]: https://blog.csdn.net/andy_wcl/article/details/81631609
[image-20210607180101180]: /images/20221005/b228155d160a425abf34a2bd5dabc1a8.png
[image-20210607180222816]: /images/20221005/20bb86578a4340e09285eb149ed629bf.png
[image-20210606165856483]: /images/20221005/4e2f13e9d0064ad7950451212f7b5cb1.png
[ElasticSearch]: https://www.elastic.co/cn/downloads/elasticsearch
[elasticsearch-head-master]: https://github.com/mobz/elasticsearch-head/archive/refs/heads/master.zip
[Kibana]: https://www.elastic.co/cn/kibana
[image-20210607181057441]: /images/20221005/1e86349b94bc4f0b903cf7a2938dbf0b.png
[IK]: https://github.com/medcl/elasticsearch-analysis-ik/releases
[image-20210606181727878]: /images/20221005/da509b4ffe414cacb2dff3110520f228.png
[image-20210606182122961]: /images/20221005/dba2a039ea5c439aa08b7bdbffb3839f.png
[image-20210606195047352]: /images/20221005/fc9954e2da1944a19dc9c27ee01aecbf.png
[image-20210606195444729]: /images/20221005/2faa0e050716456cb58cbd6aa6c2c2fa.png
[image-20210606200356058]: /images/20221005/0a6a337b4dac4f0ab09a029a21c5f6d7.png
[image-20210608104025028]: /images/20221005/b6bcaafd3bd64c819e9996c5aaf79c48.png
[image-20210609195403771]: /images/20221005/90426cbc4deb48f8b6948abec2d4d47b.png
[image-20210609200132756]: /images/20221005/775aec3161af42a5864a73f302644e82.png
[image-20210609200023117]: /images/20221005/c77f7c74eb154c599fb21364468c5b70.png
[image-20210609203151874]: /images/20221005/f8da555080884b4ebe902502b98205f6.png
[ElasticSearch 1]: https://blog.csdn.net/yy339452689/article/details/105865771
[img]: /images/20221005/748e0c01ea2949d3b067091c8f1edc69.png
[Link 4]: https://www.bilibili.com/video/BV1Nk4y1R7Hf