ElasticSearch

感谢狂神的分享：B站视频连接

官网：https://www.elastic.co/cn

1. 概述

前言

ElasticSearch

• ElaticSearch，简称为ES。ES是一个开源的高扩展的分布式全文检索引擎，它可以近乎 实时地存储、检索数据；本身扩展性很好，可以扩展到上百台服务器，处理 PB 级别（大数据时代）的数据。
• ES由 Java 语言开发并使用 Lucene 作为其核心来实现所有索引和搜索的功能，但是它的目的是通过简单的 restfull API 来隐藏 Lucene 的复杂性，从而让全文搜索变得简单。据国际权威的数据库产品评测机构 DB Engines 的统计，在2016 年1月，ElasticSearch 已超过 Solr 等，成为排名第一的搜索引擎类应用。
• ELK： Logstash 和 Beats 有助于收集、聚合数据并将其存储在Elasticsearch 中。Kibana 能够以交互方式探索、可视化和分享对数据的见解，并管理和监控堆栈。Elasticsearch 实时的搜索、分析数据
• Lucene是用JAVA写成的，目标是为各种中小型应用软件加入全文检索功能。因为好用而且开源(代码公开），非常受程序员们的欢迎。Lucene 是一套信息检索工具包（jar包），不包含搜索引擎系统。

Lucene简介

官网：https://lucene.apache.org/

• Lucene 是apache软件基金会4 jakarta项目组的一个子项目，是一个开源的全文检索引擎工具包。但它不是一个完整的全文检索引擎，而是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎，部分文本分析引擎（英文与德文两种西方语言)。Lucene的目的是为软件开发人员提供一个简单易用的工具包，以方便的在目标系统中实现全文检索的功能，或以此为基础建立起完整的全文检索引擎。
• Lucene是一套用于全文检索和搜寻的开源程式库，由Apache软件基金会支持和提供。Lucene提供了一个简单却强大的应用程式接口，能够做全文索引和搜寻。在Java开发环境里Lucene是一个成熟的免费开源工具。就其本身而言，Lucene是当前以及最近几年最受欢迎的免费Java信息检索程序库。人们经常提到信息检索程序库，虽然与搜索引擎有关，但不应该将信息检索程序库与搜索引擎相混淆。
• Lucene是一个全文检索引擎的架构。那什么是全文搜索引擎?
  全文搜索引擎是名副其实的搜索引擎，国外具代表性的有Google、Fast/AliTheWeb、AltaVista、Inktomi、Teoma、WiseNut等，国内著名的有百度(Baidu )。它们都是通过从互联网上提取的各个网站的信息（以网页文字为主）而建立的数据库中，检索与用户查询条件匹配的相关记录，然后按一定的排列顺序将结果返回给用户，因此他们是真正的搜索引擎。
• 从搜索结果来源的角度，全文搜索引擎又可细分为两种：一种是拥有自己的检索程序(Indexer )，俗称"蜘蛛" ( Spider )程序或"机器人" ( Robot)程序，并自建网页数据库，搜索结果直接从自身的数据库中调用，如上面提到的7家引擎；另一种则是租用其他引擎的数据库，并按自定的格式排列搜索结果，如Lycos引擎

ElasticSearch简介

Elasticsearch 是一个实时分布式搜索和分析引擎。它让你以前所未有的速度处理大数据成为可能。它用于全文搜索、结构化搜索、分析以及将这三者混合使用︰

1. 维基百科使用Elasticsearch提供全文搜索并高亮关键字，以及输入实时搜索(search-asyou-type)和搜索纠错(did-you-mean)等搜索建议功能。
2. 英国卫报使用Elasticsearch结合用户日志和社交网络数据提供给他们的编辑以实时的反馈，以便及时了解公众对新发表的文章的回应。
3. StackOverflow 结合全文搜索与地理位置查询，以及more-like-this功能来找到相关的问题和答案。Github使用Elasticsearch检索1300亿行的代码。

但是Elasticsearch不仅用于大型企业，它还让像DataDog以及Klout这样的创业公司将最初的想法变成可扩展的解决方案。Elasticsearch可以在你的笔记本上运行，也可以在数以百计的服务器上处理PB级别的数据。

Elasticsearch是一个基于Apache Lucene™的开源搜索引擎。无论在开源还是专有领域，Lucene可以被认为是迄今为止最先进、性能最好的、功能最全的搜索引擎库。

但是，Lucene只是一个库。想要使用它，你必须使用Java来作为开发语言并将其直接集成到你的应用中，更糟糕的是, Lucene非常复杂，你需要深入了解检索的相关知识来理解它是如何工作的。

Elasticsearch也使用Java开发并使用Lucene作为其核心来实现所有索引和搜索的功能，但是它的目的是通过简单的RESTful API来隐藏Lucene的复杂性，从而让全文搜索变得简单。

Solr简介

Solr 是 Apache 下的一个顶级开源项目，采用 Java开发，它是基于Lucene的全文搜索服务器。Solr提供了比Lucene更为丰富的查询语言，同时实现了可配置、可扩展，并对索引、搜索性能进行了优化

Solr可以独立运行，运行在Ietty、Tomcat等这些Servlet容器中。Solr索引的实现方法很简单：用POST方法向Solr服务器发送一个描述Field及其内容的XML文档，Solr根据xml文档添加、删除、更新索引。Solr搜索只需要发送HTTP GET请求然后对 Solr返回Xml.json等格式的查询结果进行解析，组织页面布局。Solr不提供构建UI的功能，只提供了一个管理界面，通过管理界面可以查询Solr的配置和运行情况。

Solr是一个独立的企业级搜索应用服务器，对外提供类似于Web-service的APl接口。用户可以通过http请求，向搜索引擎服务器提交一定格式的文件，生成索引；也可以通过提出查找请求,并得到返回结果

ES与Solr对比

对比项	ElasticSearch	Solr
安装	开箱即用(解压就能用) ，非常简单。	Solr安装略微复杂
分布式管理	ES 自身带有分布式协调管理功能	利用Zookeeper进行分布式管理
支持的数据格式	仅支持 JSON	支持多种数据格式：JSON、XML、 CSV
功能多少	ES 更注重于核心功能：高级功能由第三方插件提供，例如图形化界面需要kibana支撑	Solr 官方提供的功能更多
速度	ES建立索引快(即查询慢) ，即实时性查询快，用于facebook新浪等搜索	Solr 查询快，但更新索引慢(即插入删除慢) ，用于电商等查询多的应用
应用方面	ES更适用于新兴的实时搜索应用	Solr是传统搜索应用的有力解决方案
社区	ES 相对开发维护者较少、更新太快、学习成本较高	Solr比较成熟，有一个更大、更成熟的用户、开发和贡献者社区

2. 安装ES

官网下载：https://www.elastic.co/cn/downloads/elasticsearch

历史版本下载：https://www.elastic.co/cn/downloads/past-releases/

1. 下载好解压缩即可，文件目录如下：
   
   
2. 双击 bin/elasticsearch.bat ，如下所示：
   
3. 安装可视化界面 elasticsearch-head
   • 先安装node.js：https://nodejs.org/en/download/
   • 下载安装 ES-head：https://github.com/mobz/elasticsearch-head
     
   • 访问（有跨域问题，如下所示）
     
     修改 config/elsaticsearch.yml，添加下面的配置：
     
   • 重启es，使用es-hdea连接，如下所示
     
4. 说明
   • 索引 —类比—> “数据库”；类型 —类比—> “表”；文档 —类比—> “库中的数据（表中的行）”

安装 kibana

Kibana是一个针对Elasticsearch的开源分析及可视化平台，用来搜索、查看交互存储在Elasticsearch索引中的数据。使用Kibana ,可以通过各种图表进行高级数据分析及展示。Kibana让海量数据更容易理解。它操作简单，基于浏览器的用户界面可以快速创建仪表板( dashboard ) 实时显示Elasticsearch查询动态。设置Kibana非常简单。无需编码或者额外的基础架构，几分钟内就可以完成Kibana安装并启动Elasticsearch索引监测。kibana版本要与ES保持一致。

官网: https://www.elastic.co/cn/downloads/kibana

下载对应版本，启动 bin/kibana.bat ，如下所示：


汉化 Kibana：

1. 编辑器打开kibana目录 /config/kibana.yml，添加：

i18n.locale: "zh-CN"

2. 重启Kibana，汉化成功
   

了解ELK

ELK 是Elasticsearch、Logstash、Kibana 三大开源框架首字母大写简称。市面上也被成为Elastic Stack。

• Elasticsearch是一个基于Lucene、分布式、通过 Restful 方式进行交互的近实时搜索平台框架。像类似百度、谷歌这种大数据全文搜索引擎的场景都可以使用Elasticsearch作为底层支持框架，可见Elasticsearch提供的搜索能力确实强大。
• Logstash 是ELK的中央数据流引擎，用于从不同目标（文件/数据存储/MQ）收集的不同格式数据，经过过滤后支持输出到不同目的地(文件/MQ/redis/elasticsearch/kafka等 )。
• Kibana 可以将elasticsearch的数据通过友好的页面展示出来，提供实时分析的功能.

市面上很多开发只要提到ELK能够一致说出它是一个日志分析架构技术栈总称，但实际上ELK不仅仅适用于日志分析，它还可以支持其它任何数据分析和收集的场景，日志分析和收集只是更具有代表性，并非唯一性。

3. ES核心概念

概述

1. 索引（index）
2. 字段类型 / 映射（Mapping）
3. 文档（document）
4. 分片（Lucene索引，倒排索引）

ElasticSearch是面向文档，一切都是JSON！关系型数据库和ElasticSearch客观对比如下：

Relational DB	ElasticSearch
数据库（database）	索引（indices）
表（tables）	类型 (types，慢慢会被弃用)
行（rows）	文档（documents）
字段（columns）	fields

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

物理设计：

• elasticsearch在后台把每个索引划分成多个分片，每分分片可以在集群中的不同服务器间迁移
• 一台服务器就是一个集群！即启动的ElasticSearch服务，默认就是一个集群，且默认集群名为elasticsearch
  

逻辑设计：

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

文档

elasticsearch是面向文档的，意味着索引和搜索数据的最小单位是文档。文档有几个重要属性︰

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

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

类型

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

索引

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

创建新索引：

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

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

倒排索引（Lucene索引底层）

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

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

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

现在，我们试图搜索to forever，只需要查看包含每个词条的文档。

两个文档都匹配，但是第一个文档比第二个匹配程度更高。如果没有别的条件，现在，这两个包含关键字的文档都将返回。

简单说就是： 按（文章关键字，对应的文档0个或多个）形式建立索引，根据关键字就可直接查询对应的文档（含关键字的），无需查询每一个文档，如下图

通过博客标签来搜索博客文章，那么倒排索引列表就是这样的一个结构:

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

elasticsearch的索引和Lucene的索引对比

在 ES 中，索引（库)这个词被频繁使用，索引被分为多个分片，每份分片是一个Lucene的索引。所以一个ES索引是由多个Lucene索引组成的。ES使用Lucene 作为底层呢。

4. IK 分词器

IK分词器：中文分词器

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

IK提供了两个分词算法: ik_smart（最少切分） 和 ik_max_word （最细粒度划分）

1、下载

版本要与ElasticSearch版本对应

下载地址：https://github.com/medcl/elasticsearch-analysis-ik/releases

2、安装

解压即可（ 需要解压到ElasticSearch的plugins目录，ik 文件夹下----安装目录不要有中文、空格 ）

3、重启ElasticSearch
加载了 ik 分词器插件：

4、查看 ES 加载的所有插件列表
重新打开一个cmd窗口，执行 elasticsearch-plugin list 命令，就能观察到 ES 的插件列表：

5、使用kibana测试

• ik_smart：最少切分
  
• ik_max_word：最细粒度划分（穷尽词库的可能）
  
  6、添加自定义的词，到扩展字典中

从上面看，感觉分词都比较正常；但是大多数，分词都满足不了我们的想法，如下例：

这时，我们需要手动将该词添加到分词器的词典当中

1. elasticsearch目录 /plugins/ik/config/IKAnalyzer.cfg.xml
   
2. 打开配置文件，配置自定义词典
   
3. 编写自定义词典
   
4. 重启ES，再次测试
   

5. Rest 风格

一种软件架构风格，而不是标准，只是提供了一组设计原则和约束条件。它主要用于客户端和服务器交互类的软件。基于这个风格设计的软件可以 更简洁、更有层次、更易于实现缓存等机制。

基本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/索引名称/类型名称/文档id/_search	查询所有数据

测试

1、创建一个索引，添加

PUT /索引名/~类型名(未来可能取消不写)~/文档id
{请求体}

2、字段数据类型

• 字符串类型

  • text、keyword
    • text：支持分词，全文检索,支持模糊、精确查询,不支持聚合,排序操作;text类型的最大支持的字符长度无限制,适合大字段存储；
    • keyword：不进行分词，直接索引、支持模糊、支持精确匹配，支持聚合、排序操作。
    • keyword：类型的最大支持的长度为——32766个UTF-8类型的字符,可以通过设置ignore_above指定自持字符长度，超过给定长度后的数据将不被索引，无法通过term精确匹配检索返回结果。

• 数值型

  • long、Integer、short、byte、double、float、half float、scaled float

• 日期类型

  • date

• te布尔类型

  • boolean

• 二进制类型

  • binary

3、 指定字段的类型（使用PUT）

创建索引的时候，可以指定字段和类型。可以在 es-head 中查看索引信息，也可以使用 " Get /{索引名称} " 获取索引详情。

4、GET _cat/{查询字段}

GET _cat/indices
GET _cat/aliases
GET _cat/allocation
GET _cat/count
GET _cat/fielddata
GET _cat/health
GET _cat/indices
GET _cat/master
GET _cat/nodeattrs
GET _cat/nodes
GET _cat/pending_tasks
GET _cat/plugins
GET _cat/recovery
GET _cat/repositories
GET _cat/segments
GET _cat/shards
GET _cat/snapshots
GET _cat/tasks
GET _cat/templates
GET _cat/thread_pool

5、修改

• PUT 命令（原始方法，会完全覆盖所有字段的值）
  
• POST /..../_update 命令（只更新指定字段的值）
  
  6、删除
  
  7、简单查询

在索引中插入三条数据：

GET /test3/_doc/_search?q=name:熊大

8、复杂查询

1. 查询匹配
   match： 匹配（会使用分词器解析（先分析文档，然后进行查询））
   _source：过滤字段
   sort： 排序
   form、size 分页
   

2. 多条件查询

must ：相当于 and
should ：相当于 or
must_not ：相当于 not (… and …)
filter ：过滤

3. 匹配属组
貌似不能与其它字段一起使用
可以多关键字查（空格隔开）— 匹配字段也是符合的
match 会使用分词器解析（先分析文档，然后进行查询）

4. 精确查询
term 直接通过 倒排索引 指定词条查询
适合查询 number、date、keyword ，不适合text

5. text和keyword

• text：
  • 支持分词，全文检索；支持模糊、精确查询，不支持聚合、排序操作;
  • text类型的最大支持的字符长度无限制，适合大字段存储；
• keyword：
  • 不进行分词，直接索引；支持模糊、精确匹配，支持聚合、排序操作。
  • keyword 类型的最大支持的长度为——32766个UTF-8类型的字符，可以通过设置 ignore_above 指定自持字符长度，超过给定长度后的数据将不被索引，无法通过 term 精确匹配检索返回结果。

// 测试keyword和text是否支持分词
// 设置索引类型
PUT /test
{
    "mappings": {
        "properties": {
            "text":{
                "type":"text"
             },
            "keyword":{
                "type":"keyword"
             }
        }
    }
}
------------------------------放入数据---------------------------------------
// 设置字段数据
PUT /test/_doc/1
{
"text":"测试keyword和text是否支持分词",
"keyword":"测试keyword和text是否支持分词"
}
------------------------------测试分词-----------------------------------
// text 支持分词
// keyword 不支持分词
GET /test/_doc/_search
{
    "query":{
        "match":{
            "text":"测试"
        }
    }
}// 查的到

GET /test/_doc/_search
{
        "query":{
            "match":{
                "keyword":"测试"
            }
        }
}// 查不到，必须是 "测试keyword和text是否支持分词" 才能查到

------------------------------测试分词方法-----------------------------------
 
GET _analyze
{
"analyzer": "keyword",
"text": ["测试liu"]
}// 不会分词，即 测试liu
 
GET _analyze
{
"analyzer": "standard",
"text": ["测试liu"]
}// 分为 测 试 liu
 
GET _analyze
{
"analyzer":"ik_max_word",
"text": ["测试liu"]
}// 分为 测试 liu

6. 高亮查询
   

6. 集成SpringBoot

1. 找文档
   
   推荐使用 Java Rest Client
   
   
2. 引入maven依赖

• 官方推荐的maven依赖如下：
  
• 如果使用SpringBoot集成，则导入SpringData下面的包即可

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>

3. 客户端的依赖关系
   
4. 初始化
   
5. 创建 SpringBoot 项目
   
   要保证maven依赖的ES于下载的版本一致：
   
   
6. 源码分析
   
7. 测试

• 配置类

@Configuration
public class ESConfig {
    @Bean
    public RestHighLevelClient restHighLevelClient(){
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost", 9200, "http")));
        return client;
    }
}

• 实体类

@AllArgsConstructor
@NoArgsConstructor
@Data
public class User implements Serializable {
    private static final long serialVersionUID = -3843548915035470817L;
    private String name;
    private Integer age;
}

• 测试方法

@SpringBootTest
class XinanEsApiApplicationTests {
    @Resource
    private RestHighLevelClient restHighLevelClient;
	// -----------------创建索引-------------------
    @Test
    void contextLoads() throws IOException {
        // 创建索引的请求，并执行
        CreateIndexRequest request = new CreateIndexRequest("boot_index");
        CreateIndexResponse response = restHighLevelClient.indices().create(request, RequestOptions.DEFAULT);

        System.out.println(response.isAcknowledged());  // 查看是否创建成功
        System.out.println(response);   // 查看返回对象
        restHighLevelClient.close();    // 关闭连接
    }

	// -----------------测试索引是否存在-------------------
	@Test
    void testExistIndex() throws IOException {
        GetIndexRequest request = new GetIndexRequest("boot_index");
        boolean exists = restHighLevelClient.indices().exists(request, RequestOptions.DEFAULT);
        System.out.println(exists);
    }
    // -----------------删除索引-------------------
    @Test
    void testDeleteIndex() throws IOException {
        DeleteIndexRequest request = new DeleteIndexRequest("ahui_index");
        //删除
        AcknowledgedResponse delete = restHighLevelClient.indices().delete(request, RequestOptions.DEFAULT);
        System.out.println(delete.isAcknowledged());
    }

	// -----------------添加文档-------------------
	@Test
    void testAddDocument() throws IOException {
        //创建对象
        User user = new User("黑皇", 9999);
        //创建请求
        IndexRequest request = new IndexRequest("boot_index");

        //规则 put boot_index/_doc/1
        request.id("1");
        request.timeout(TimeValue.timeValueSeconds(1));
        request.timeout("1s");

        //将数据放入请求 json (使用fastjson进行转换)
        IndexRequest source = request.source(JSON.toJSONString(user), XContentType.JSON);
        //客户端发送请求, 获取响应的结果
        IndexResponse indexResponse = restHighLevelClient.index(request, RequestOptions.DEFAULT);
        //返回具体的json信息
        System.out.println(indexResponse.toString());
        //对应我们命令返回的状态 CREATED
        System.out.println(indexResponse.status());
    }

	@Test
    // -----------------查询文档是否存-------------------
    void testIsExistes() throws IOException {
        GetRequest getRequest = new GetRequest("boot_index", "1");
        //不获取返回的_source 的上下文了
        getRequest.fetchSourceContext(new FetchSourceContext(false));
        getRequest.storedFields("_none_");

        boolean exists = restHighLevelClient.exists(getRequest, RequestOptions.DEFAULT);
        System.out.println(exists);	    // 打印： true
    }

    @Test
    // -----------------获取文档内容-------------------
    void testGetDocument() throws IOException {
        GetRequest getRequest = new GetRequest("boot_index", "1");
        GetResponse getResponse = restHighLevelClient.get(getRequest, RequestOptions.DEFAULT);
        //打印文档的内容
        System.out.println(getResponse.getSourceAsString());    // 打印： {"age":9999,"name":"黑皇"}
        //返回的全部内容和命令是一样的
        System.out.println(getResponse);
    }

    @Test
    
    // -----------------更新文档-----------------
    void testUpdateRequest() throws IOException {
        UpdateRequest updateRequest = new UpdateRequest("boot_index", "1");
        updateRequest.timeout("1s");

        User user = new User("叶凡", 26);
        updateRequest.doc(JSON.toJSONString(user),XContentType.JSON);

        UpdateResponse updateResponse = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);
        System.out.println(updateResponse.status());    // 打印： OK
    }

    @Test
    //-----------------删除文档记录-----------------
    void testDeleteRequest() throws IOException {
        DeleteRequest deleteRequest = new DeleteRequest("boot_index", "1");
        deleteRequest.timeout("1s");

        DeleteResponse delete = restHighLevelClient.delete(deleteRequest, RequestOptions.DEFAULT);
        System.out.println(delete.status());    // 打印： OK

    }

    @Test
    //-----------------批量插入-----------------
    void testBulkRequest() throws IOException{
        BulkRequest bulkRequest = new BulkRequest();
        bulkRequest.timeout("10s");

        ArrayList<User> userList = new ArrayList<>();
        userList.add(new User("ahui1",18));
        userList.add(new User("ahui2",18));
        userList.add(new User("ahui3",18));
        userList.add(new User("onlylmf1",18));
        userList.add(new User("onlylmf2",18));
        userList.add(new User("onlylmf3",18));

        //批量处理请求
        for (int i = 0; i < userList.size(); i++) {
            //批量更新和批量修改等, 就在这里修改对应的请求就可以了
            bulkRequest.add(new IndexRequest("boot_index")
                    .id("" + (i + 1)) //不加id的话会默认生成随机id
                    .source(JSON.toJSONString(userList.get(i)),XContentType.JSON));
        }
        BulkResponse bulkResponse = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
        //是够失败, 返回false代表成功
        System.out.println(bulkResponse.hasFailures());     // 打印： false (代表成功)
    }

    
    /** 查询
     * SearchRequest 搜索请求
     * SearchSourceBuilder 条件构造
     * HighLightBuilder 构建高亮
     * xxx QueryBuilder 对应我们刚才看到的所有命令
     */
    @Test
    void testSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("boot_index");
        //构建搜索条件
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        //查询条件,我们可以使用QueryBuilders 工具类来实现
        //QueryBuilders.termQuery  精确匹配
        //QueryBuilders.matchAllQuery 匹配所有
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name", "ahui1");
//        MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
        sourceBuilder.query(termQueryBuilder);
        sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));

        searchRequest.source(sourceBuilder);

        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        System.out.println(JSON.toJSONString(searchResponse.getHits()));
        System.out.println("==========================================");
        for (SearchHit documentFileds : searchResponse.getHits().getHits()) {
            System.out.println(documentFileds.getSourceAsMap());    //打印： {name=ahui1, age=18}
        }
    }

}

7. JD实战

7.1 搭建项目

项目上传到gitee上：https://gitee.com/wxawangxinan/elastic_search.git

7.2 爬虫

1. 获取地址：
   复制京东搜索连接：https://search.jd.com/Search?keyword=java
2. 查看网页元素：
   
3. 导入依赖

<!-- jsoup解析页面 （爬视频，研究tiko）-->
<!-- https://mvnrepository.com/artifact/org.jsoup/jsoup -->
<dependency>
    <groupId>org.jsoup</groupId>
    <artifactId>jsoup</artifactId>
    <version>1.15.3</version>
</dependency>
<!-- alibaba fastJson -->
<dependency>
    <groupId>com.alibaba.fastjson2</groupId>
    <artifactId>fastjson2</artifactId>
    <version>2.0.17</version>
</dependency>

4. 编写工具类，爬虫页面信息

public class HtmlParseUtil {

    public static void main(String[] args) throws IOException {
        // 请求的网页地址
        String url = "https://search.jd.com/Search?keyword=java";
        // 解析网页（Jsou返回的Document，就是浏览器的Docuement对象）
        Document document = Jsoup.parse(new URL(url),3000);
        //根据id获取标签元素。 所有在js里面使用的方法在这里都可以使用
        Element goodsElement = document.getElementById("J_goodsList");
        // 获取所有的li元素
        Elements elements = goodsElement.getElementsByTag("li");
        // 获取元素中的内容
        for (int i = 0; i < elements.size(); i++) {
            Element el = elements.get(i);
            //这里有一点要注意，直接attr使用src是爬不出来的，因为京东使用了img懒加载
            String img = el.getElementsByTag("img").eq(0).attr("data-lazy-img");
            //获取商品的具体信息，并且只获取第一个text文本内容
            String price = el.getElementsByClass("p-price").eq(0).text();
            String title = el.getElementsByClass("p-name").eq(0).text();
            String shopName = el.getElementsByClass("p-shop").eq(0).text();

            System.out.println("-----------------------------------");
            System.out.println(img);
            System.out.println(price);
            System.out.println(title);
            System.out.println(shopName);
        }
    }
}

5. 测试结果
   
6. 创建实体类

@AllArgsConstructor
@NoArgsConstructor
@Data
public class Content {
    private String title;
    private String img;
    private String price;
}

7. 封装工具类

public class HtmlParseUtil {

    public static List<Content> parseJd(String keyWords) throws IOException{
        List<Content> list = new ArrayList<>();
        // 请求的网页地址
        String url = "https://search.jd.com/Search?keyword="+keyWords;
        // 解析网页（Jsou返回的Document，就是浏览器的Docuement对象）
        Document document = Jsoup.parse(new URL(url),3000);
        //根据id获取标签元素。 所有在js里面使用的方法在这里都可以使用
        Element goodsElement = document.getElementById("J_goodsList");
        // 获取所有的li元素
        Elements elements = goodsElement.getElementsByTag("li");
        // 获取元素中的内容
        for (int i = 0; i < elements.size(); i++) {
            Element el = elements.get(i);
            //这里有一点要注意，直接attr使用src是爬不出来的，因为京东使用了img懒加载
            String img = el.getElementsByTag("img").eq(0).attr("data-lazy-img");
            //获取商品的具体信息，并且只获取第一个text文本内容
            String price = el.getElementsByClass("p-price").eq(0).text();
            String title = el.getElementsByClass("p-name").eq(0).text();

            Content content = new Content(title, img, price);
            list.add(content);
        }
        return list;
    }

}

8. 编写业务层代码，将爬虫数据注入到ES中

@Service
public class ContentService {
    // 注入ES客户端
    @Resource
    private RestHighLevelClient restHighLevelClient;

    //根据关键字爬虫京东，并将数据放入ES中
    public boolean parseContentJd(String keyWords){
        try {
            // 批量请求的对象
            BulkRequest bulkRequest = new BulkRequest();
            // 调用工具类，爬虫数据
            List<Content> contents = HtmlParseUtil.parseJd(keyWords);
            // 将实体类对象，放入ES
            for (int i = 0; i < contents.size(); i++) {
                Content content = contents.get(i);
                bulkRequest.add(new IndexRequest("xinan_jd").source(JSON.toJSONString(content),XContentType.JSON));
            }
            // 执行请求
            BulkResponse bulk = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
            // 返回请求结果
            return !bulk.hasFailures();

        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

}

9. Controller层

@RestController
@RequestMapping("/content")
public class ContentController {
    @Autowired
    private ContentService contentService;
	// restful风格接口
    @RequestMapping("parseJd/{keyWords}")
    public boolean parseJd(@PathVariable("keyWords") String keyWords){
        boolean flag = contentService.parseContentJd(keyWords);
        return flag;
    }

}

10. 项目整体结构
    
11. 验证结果
    

7.3 搜索

1. 新增 ContentService 中的查询方法

public List<Map<String,Object>> searchPages(String keyWords, int pageNo, int pageSize) throws IOException {
    List<Map<String,Object>> list = new ArrayList<>();

    if(pageSize < 1){
        pageSize = 1;
    }

    // 查询请求
    SearchRequest searchRequest = new SearchRequest("xinan_jd");
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    // 分页
    searchSourceBuilder.from(pageNo).size(pageSize);
    // 精准匹配
    TermQueryBuilder titleQuery = QueryBuilders.termQuery("title", keyWords);

    //构建查询实体类
    searchSourceBuilder.query(titleQuery);
    searchSourceBuilder.timeout(new TimeValue(5, TimeUnit.SECONDS));
    // 执行搜索
    SearchRequest source = searchRequest.source(searchSourceBuilder);
    SearchResponse search = restHighLevelClient.search(source, RequestOptions.DEFAULT);
    // 解析返回的结果
    for (SearchHit hit : search.getHits().getHits()) {
        list.add(hit.getSourceAsMap());
    }
    return list;
}

2. 新增Controller接口

// 查询ES中的数据
@RequestMapping("/searchPages/{keyWords}/{pageNo}/{pageSize}")
public List<Map<String,Object>> searchPages(@PathVariable("keyWords") String keyWords,
                                            @PathVariable("pageNo") int pageNo,
                                            @PathVariable("pageSize") int pageSize){
    try {
        List<Map<String, Object>> maps = contentService.searchPages(keyWords, pageNo, pageSize);
        return maps;
    } catch (IOException e) {
        e.printStackTrace();
        return null;
    }
}

3. 调用验证
   点击链接：http://localhost:9090/content/searchPages/python/1/10，结果如下图：
   

7.4 前后端分离

1. 首先导入axios.js、jquery.js、vue.js文件：
   
2. 前端使用Vue接收数据
   

<script th:src="@{/js/axios.js}"></script>
<script th:src="@{/js/vue.js}"></script>
<script>
    new Vue({
        el: "#app",
        data: {
            keyWord: "",   // 搜索的关键字
            result: []      // 搜索的结果
        },
        methods:{
            searchKey(){
                var keyWord = this.keyWord;
                console.log(keyWord);
                axios.get('/content/searchPages/'+keyWord+'/1/10').then(response =>{
                    console.log(response);
                    this.result = response.data;
                })
            }
        }
    })
</script>

3. 绑定关键字与搜索方法
   
4. 将返回的结果，展示在页面上
   
5. 测试结果：
   

7.5 高亮显示

1. 修改service层方法

// 高亮显示
public List<Map<String,Object>> searchPagesHighlight(String keyWords, int pageNo, int pageSize) throws IOException {
    List<Map<String,Object>> list = new ArrayList<>();

    if(pageSize < 1){
        pageSize = 1;
    }

    // 查询请求
    SearchRequest searchRequest = new SearchRequest("xinan_jd");
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    // 分页
    searchSourceBuilder.from(pageNo).size(pageSize);
    // 精准匹配
    TermQueryBuilder titleQuery = QueryBuilders.termQuery("title", keyWords);
    //-------------------------------- 高亮显示 -------------------------
    HighlightBuilder highlightBuilder = new HighlightBuilder(); //高亮构造器
    highlightBuilder.field("title");
    highlightBuilder.preTags("<span style='color:red'>");
    highlightBuilder.postTags("</span>");
    searchSourceBuilder.highlighter(highlightBuilder);

    //构建查询实体类
    searchSourceBuilder.query(titleQuery);
    searchSourceBuilder.timeout(new TimeValue(5, TimeUnit.SECONDS));
    // 执行搜索
    SearchRequest source = searchRequest.source(searchSourceBuilder);
    SearchResponse search = restHighLevelClient.search(source, RequestOptions.DEFAULT);
    // 解析返回的结果
    for (SearchHit hit : search.getHits().getHits()) {
        // 获取每条记录的信息
        Map<String, Object> sourceAsMap = hit.getSourceAsMap();
        // 获取高亮字段
        Map<String, HighlightField> highlightFields = hit.getHighlightFields();
        HighlightField title = highlightFields.get("title");
        // 将原纪录中的字段，替换成高亮字段
        if(title != null){
            Text[] fragments = title.fragments();
            StringBuilder new_title = new StringBuilder();
            for (Text text : fragments) {
                new_title.append(text);
            }
            sourceAsMap.put("title",new_title.toString());  //高亮字段替换掉原来的内容
        }
        list.add(sourceAsMap);
    }
    return list;
}

2. 前端页面展示了高亮的标签，未显示红色：
   
3. 调整前端写法，成功展示高亮