ElasticSearch

ElasticSearch集成springboot：

Elasticsearch集成SpringBoot_elasticsearch springboot 集成-CSDN博客

版本：ElasticSearch 7.6.1（全网最新了）

6.X 7.X 的区别十分大， 6.x 的 API （原生 API、RestFul 高级！）

Lucene 是一套信息检索工具包！ jar 包！ 不包含 搜索引擎系统！

包含的：索引结构！ 读写索引的工具！排序，搜索规则… 工具类！

Lucene 和 ElasticSearch 关系：ElasticSearch 是基于 Lucene 做了一些封装和增强。

ElasticSearch 概述

Elaticsearch，简称为 es， es 是一个开源的高扩展的分布式全文检索引擎，同时ES还是一个分布式文档数据库。它可以近乎实时的存储、检索数据；本身扩展性很好，可以扩展到上百台服务器，处理 PB 级别（大数据时代）的数据。es 也使用 Java 开发并使用 Lucene 作为其核心来实现所有索引和搜索的功能，但是它的目的是通过简单的 RESTful API 来隐藏 Lucene 的复杂性，从而让全文搜索变得简单。

据国际权威的数据库产品评测机构 DB Engines 的统计，在 2016 年 1 月，ElasticSearch 已超过 Solr 等，成为排名第一的搜索引擎类应用。

谁在使用：

1、维基百科，类似百度百科，全文检索，高亮，搜索推荐/2 （权重，百度！）

2、The Guardian（国外新闻网站），类似搜狐新闻，用户行为日志（点击，浏览，收藏，评论）+社交网络数据（对某某新闻的相关看法），数据分析，给到每篇新闻文章的作者，让他知道他的文章的公众反馈（好，坏，热门，垃圾，鄙视，崇拜）

3、Stack Overflow（国外的程序异常讨论论坛），IT 问题，程序的报错，提交上去，有人会跟你讨论和回答，全文检索，搜索相关问题和答案，程序报错了，就会将报错信息粘贴到里面去，搜索有没有对应的答案

4、GitHub（开源代码管理），搜索上千亿行代码

5、电商网站，检索商品

6、日志数据分析，logstash 采集日志，ES 进行复杂的数据分析，ELK 技术， elasticsearch+logstash+kibana

7、商品价格监控网站，用户设定某商品的价格阈值，当低于该阈值的时候，发送通知消息给用户，比如说订阅牙膏的监控，如果高露洁牙膏的家庭套装低于 50 块钱，就通知我，我就去买。

8、BI 系统，商业智能，Business Intelligence。比如说有个大型商场集团，BI，分析一下某某区域最近

3 年的用户消费金额的趋势以及用户群体的组成构成，产出相关的数张报表，**区，最近 3 年，每年消费金额呈现 100%的增长，而且用户群体 85%是高级白领，开一个新商场。ES 执行数据分析和挖掘，Kibana 进行数据可视化

9、国内：站内搜索（电商，招聘，门户，等等），IT 系统搜索（OA，CRM，ERP，等等），数据分析（ES 热门的一个使用场景）

ES 和 solr 的差别

架构选择！

Elasticsearch 简介

Elasticsearch 是一个实时分布式搜索和分析引擎。它让你以前所未有的速度处理大数据成为可能。

它用于全文搜索、结构化搜索、分析以及将这三者混合使用：

维基百科使用 Elasticsearch 提供全文搜索并高亮关键字，以及输入实时搜索(search-asyou-type)和搜索纠错(did-you-mean)等搜索建议功能。

英国卫报使用 Elasticsearch 结合用户日志和社交网络数据提供给他们的编辑以实时的反馈，以便及时了解公众对新发表的文章的回应。

StackOverflow 结合全文搜索与地理位置查询，以及 more-like-this 功能来找到相关的问题和答案。

Github 使用 Elasticsearch 检索 1300 亿行的代码。

但是 Elasticsearch 不仅用于大型企业，它还让像 DataDog 以及 Klout 这样的创业公司将最初的想法变成可扩展的解决方案。

Elasticsearch 可以在你的笔记本上运行，也可以在数以百计的服务器上处理 PB 级别的数据 。

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

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

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

Solr 简介

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

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

solr 是基于 lucene 开发企业级搜索服务器，实际上就是封装了 lucene。

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

Lucene 简介

Lucene 是 apache 软件基金会 4 jakarta 项目组的一个子项目，是一个开放源代码的全文检索引擎工具包，但它不是一个完整的全文检索引擎，而是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎，部分文本分析引擎（英文与德文两种西方语言）。Lucene 的目的是为软件开发人员提供一个简单易用的工具包，以方便的在目标系统中实现全文检索的功能，或者是以此为基础建立起完整的全文检索引擎。Lucene 是一套用于全文检索和搜寻的开源程式库，由 Apache 软件基金会支持和提供。Lucene 提供了一个简单却强大的应用程式接口，能够做全文索引和搜寻。在 Java 开发环境里 Lucene 是一个成熟的免费开源工具。就其本身而言，Lucene 是当前以及最近几年最受欢迎的免费 Java 信息检索程序库。人们经常提到信息检索程序库，虽然与搜索引擎有关，但不应该将信息检索程序库与搜索引擎相混淆。

Lucene 是一个全文检索引擎的架构。那什么是全文搜索引擎？

全文搜索引擎是名副其实的搜索引擎，国外具代表性的有 Google、Fast/AllTheWeb、AltaVista、Inktomi、Teoma、WiseNut 等，国内著名的有百度（Baidu）。它们都是通过从互联网上提取的各个网站的信息（以网页文字为主）而建立的数据库中，检索与用户查询条件匹配的相关记录，然后按一定的排列顺序将结果返回给用户，因此他们是真正的搜索引擎。

从搜索结果来源的角度，全文搜索引擎又可细分为两种，一种是拥有自己的检索程序（Indexer），俗称“蜘蛛”（Spider）程序或“机器人”（Robot）程序，并自建网页数据库，搜索结果直接从自身的数据库中调用，如上面提到的 7 家引擎；另一种则是租用其他引擎的数据库，并按自定的格式排列搜索结果，如Lycos 引擎。

Elasticsearch 和 Solr 比较

ElasticSearch vs Solr 总结

1、es 基本是开箱即用（解压就可以用 ! ），非常简单。Solr 安装略微复杂一丢丢！

2、Solr 利用 Zookeeper 进行分布式管理，而 Elasticsearch 自身带有分布式协调管理功能。

3、Solr 支持更多格式的数据，比如 JSON、XML、CSV，而 Elasticsearch 仅支持 json 文件格式。

4、Solr 官方提供的功能更多，而 Elasticsearch 本身更注重于核心功能，高级功能多有第三方插件提供，例如图形化界面需要 kibana 友好支撑~!

5、Solr 查询快，但更新索引时慢（即插入删除慢），用于电商等查询多的应用；

• ES 建立索引快（即查询慢），即实时性查询快，用于 facebook 新浪等搜索。

• Solr 是传统搜索应用的有力解决方案，但 Elasticsearch 更适用于新兴的实时搜索应用。

6、Solr 比较成熟，有一个更大，更成熟的用户、开发和贡献者社区，而 Elasticsearch 相对开发维护者较少，更新太快，学习使用成本较高。（趋势！）

ES和MongoDB：一次别开生面的比较

ES和MongoDB：一次别开生面的比较_es和mongodb的区别_Java小小虫的博客-CSDN博客

ElasticSearch 安装

声明：JDK1.8 ，最低要求！ ElasticSearch 客户端，界面工具！

Java 开发，ElasticSearch 的版本和我们之后对应的 Java 的核心 jar 包！ 版本对应！JDK 环境是正常！

下载

官网：Free and Open Search: The Creators of Elasticsearch, ELK & Kibana | Elastic

下载地址：Download Elasticsearch | Elastic

官网下载巨慢，翻墙，网盘中下载即可！

我们学习的话 Window 和 Linux 都可以学习！

我们这里现在 Window 下学习！

ELK 三剑客，解压即用！（web 项目！前端环境！）

window 下安装！

1、解压就可以使用了！

2、熟悉目录！

bin 启动文件

config 配置文件

log4j2 日志配置文件

jvm.options java 虚拟机相关的配置

elasticsearch.yml elasticsearch 的配置文件！ 默认 9200 端口！ 跨域！

lib 相关jar包

logs 日志！

modules 功能模块

plugins 插件！

jvm.options java 虚拟机相关的配置

3、启动，访问 9200；

4、访问测试！
127.0.0.1:9200

ES可视化工具：

网上推荐的四种客户端：
1、Elasticsearch-Head：
         一个浏览器插件，功能比较单一，只能支持索引数据的查询，无法进行增、删、改操作，如果仅仅是测试人员使用的话，勉强可以用，用来查看数据接口，可如果是研发人员，那么没有增、删、改怎么能行？直接抛弃。

2、ElasticHD：
        桌面软件，需要安装，界面比Elasticsearch-Head要美观许多，支持的功能也比较单一，只能进行查询，并且还需要写DSL语句，这个语句谁都能记得住啊，直接抛弃。

3、Kinaba：
        这可是ES官方推荐的客户端哦，它安装的ES集群的机器上面，然后提供URL进行访问，可以说是一个web版的客户端。

        索引数据操作：它不需要写DSL语句就能查询，这个是非常大的进步了哦，但是还不支持不写DSK语句进行增、删、改，这对不熟悉DSL语句的我们来说，是非常头痛的事情。想一想还是要再考察考察

4、NexNoSQL Client：
        它是一款支持Elasticsearch、Redis、MongoDB三合一的可视化客户端管理工具，也是桌面软件，需要安装。安装之后就可以添加这三种集群，然后进行相应的操作了

可选择的Elasticsearch好用的可视化客户端工具_es可视化管理工具-CSDN博客

安装可视化界面 Elasticsearch-Head 的插件

没有前端基础的，先去看我的 Vue，把基本的环境安装完毕！

1、下载地址：GitHub - mobz/elasticsearch-head: A web front end for an elastic search cluster

2、启动

文档主目录下cmd命令

npm install

npm run start

3、连接测试发现，存在跨域问题：配置 es

http://localhost:9100

配置

http.cors.enabled: true

http.cors.allow-origin: "*"

4、重启 es 服务器，然后再次连接

你们初学，就把 es 当做一个数据库！ （可以建立索引（库），文档（库中的数据！））这个 head 我们就把它当做数据展示工具！我们后面所有的查询使用Kibana！！！

了解 ELK

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

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

Elasticsearch是ELK的一个组成,是一个产品，而且是非常完善的产品，ELK代表的是：E就是ElasticSearch，L就是Logstach，K就是kibana

E：EalsticSearch 搜索和分析的功能

L：Logstach 搜集数据的功能，类似于flume（使用方法几乎跟flume一模一样），是日志收集系统

K：Kibana 数据可视化（分析），可以用图表的方式来去展示，文不如表，表不如图，是数据可视化平台

分析日志的用处：假如一个分布式系统有 1000 台机器，系统出现故障时，我要看下日志，还得一台一台登录上去查看，是不是非常麻烦？

但是如果日志接入了 ELK 系统就不一样。比如系统运行过程中，突然出现了异常，在日志中就能及时反馈，日志进入 ELK 系统中，我们直接在 Kibana 就能看到日志情况。如果再接入一些实时计算模块，还能做实时报警功能。

这都依赖ES强大的反向索引功能，这样我们根据关键字就能查询到关键的错误日志了。

安装 Kibana

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

官网：Kibana：数据的探索、可视化和分析 | Elastic

Kibana 版本要和 Es 一致！

下载完毕后，解压也需要一些时间！是一个标准的工程！

好处：ELK 基本上都是拆箱即用！

启动测试：

1、解压后端的目录

2、启动

3、访问测试

http://localhost:5601

4、开发工具！ （Post、curl、head、谷歌浏览器插件测试！）

我们之后的所有操作都在这里进行编写！很多学习大数据的人，Hadoop！

5、汉化！自己修改 kibana 配置即可！ zh-CN！

ElasticSearch的简介：智能搜索，分布式的搜索引擎

什么是搜索？

1）百度，谷歌，必应。我们可以通过他们去搜索我们需要的东西。但是我们的搜索不只是包含这些，还有京东站内搜索啊。

2）互联网的搜索：电商网站。招聘网站。新闻网站。各种APP（百度外卖，美团等等）

3）windows系统的搜索,OA软件，淘宝SSM网站，前后台的搜索功能

总结：搜索无处不在。通过一些关键字，给我们查询出来跟这些关键字相关的信息

什么是全文检索

全文检索是指计算机索引程序通过扫描文章中的每一个词，对每一个词建立一个索引，指明该词在文章中出现的次数和位置，当用户查询时，检索程序就根据事先建立的索引进行查找，并将查找的结果反馈给用户的检索方式。这个过程类似于通过字典中的检索字表查字的过程。

全文检索的方法主要分为按字检索和按词检索两种。按字检索是指对于文章中的每一个字都建立索引，检索时将词分解为字的组合。对于各种不同的语言而言，字有不同的含义，比如英文中字与词实际上是合一的，而中文中字与词有很大分别。按词检索指对文章中的词，即语义单位建立索引，检索时按词检索，并且可以处理同义项等。英文等西方文字由于按照空白切分词，因此实现上与按字处理类似，添加同义处理也很容易。中文等东方文字则需要切分字词，以达到按词索引的目的，关于这方面的问题，是当前全文检索技术尤其是中文全文检索技术中的难点，在此不做详述。

什么是倒排索引

以前是根据ID查内容，倒排索引之后是根据内容查ID，然后再拿着ID去查询出来真正需要的东西。

什么是Lucene：

Lucene就是一个jar包，里面包含了各种建立倒排索引的方法，java开发的时候只需要导入这个jar包就可以开发了。

Lucene的介绍及使用

典型的用空间换时间。

ES 和 Lucene的区别：

Lucene不是分布式的。

ES的底层就是Lucene，ES是分布式的

为什么不用数据库去实现搜索功能？

我们用搜索“牙膏”商品为例

 如果用我们平时数据库来实现搜索的功能在性能上就很差。

ES的官网：

Elasticsearch：官方分布式搜索和分析引擎 | Elastic

ES的由来：

因为Lucene有两个难以解决的问题，

1）数据越大，存不下来，那我就需要多台服务器存数据，那么我的Lucene不支持分布式的，那就需要安装多个Lucene然后通过代码来合并搜索结果。这样很不好

2）数据要考虑安全性，一台服务器挂了，那么上面的数据不就消失了。

ES就是分布式的集群，每一个节点其实就是Lucene，当用户搜索的时候，会随机挑一台，然后这台机器自己知道数据在哪，不用我们管这些底层、

 ES的优点：

1.分布式的功能

2、数据高可用，集群高可用

3.API更简单

4.API更高级。

5.支持的语言很多

6.支持PB级别的数据

7.完成搜索的功能和分析功能

基于Lucene，隐藏了Lucene的复杂性，提供简单的API

ES的性能比HBase高，咱们的竞价引擎最后还是要存到ES中的。

搜索引擎原理

反向索引又叫倒排索引，是根据文章内容中的关键字建立索引。
搜索引擎原理就是建立反向索引。
Elasticsearch 在 Lucene 的基础上进行封装，实现了分布式搜索引擎。
Elasticsearch 中的索引、类型和文档的概念比较重要，类似于 MySQL 中的数据库、表和行。
Elasticsearch 也是 Master-slave 架构，也实现了数据的分片和备份。
Elasticsearch 一个典型应用就是 ELK 日志分析系统。
 

ES支持的语言

Curl、java、c#、python、JavaScript、php、perl、ruby

Curl 'www.baidu.com' 就是linux的shell命令。可以访问百度，返回的是百度的网页代码

ES的作用

1）全文检索：

类似 select * from product where product_name like '%牙膏%'

类似百度效果（电商搜索的效果）

2）结构化搜索：

类似 select * from product where product_id = '1'

3）数据分析

类似 select count (*) from product

ES的安装

直接解压就能用（针对中小型项目），大型项目还是要调一调参数的

ES的核心概念
3.1 NRT(Near Realtime)近实时

3.2 cluster集群，ES是一个分布式的系统

ES直接解压不需要配置就可以使用，在hadoop1上解压一个ES，在hadoop2上解压了一个ES，接下来把这两个ES启动起来。他们就构成了一个集群。

 在ES里面默认有一个配置，clustername 默认值就是ElasticSearch,如果这个值是一样的就属于同一个集群，不一样的值就是不一样的集群。

3.3 Node节点，就是集群中的一台服务器
3.4 index 索引（索引库）

我们为什么使用ES？因为想把数据存进去，然后再查询出来。

我们在使用Mysql或者Oracle的时候，为了区分数据，我们会建立不同的数据库，库下面还有表的。

其实ES功能就像一个关系型数据库，在这个数据库我们可以往里面添加数据，查询数据。

ES中的索引非传统索引的含义，ES中的索引是存放数据的地方，是ES中的一个概念词汇

index类似于我们Mysql里面的一个数据库 create database user; 好比就是一个索引库

3.5 type类型

类型是用来定义数据结构的

在每一个index下面，可以有一个或者多个type，好比数据库里面的一张表。

相当于表结构的描述，描述每个字段的类型。

3.6 document：文档

文档就是最终的数据了，可以认为一个文档就是一条记录。

是ES里面最小的数据单元，就好比表里面的一条数据

3.7 Field 字段

好比关系型数据库中列的概念，一个document有一个或者多个field组成。

例如：

朝阳区：一个Mysql数据库

房子：create database chaoyaninfo

房间：create table people

3.8 shard：分片

一台服务器，无法存储大量的数据，ES把一个index里面的数据，分为多个shard，分布式的存储在各个服务器上面。

kafka：为什么支持分布式的功能，因为里面是有topic，支持分区的概念。所以topic A可以存在不同的节点上面。就可以支持海量数据和高并发，提升性能和吞吐量

3.9 replica：副本

一个分布式的集群，难免会有一台或者多台服务器宕机，如果我们没有副本这个概念。就会造成我们的shard发生故障，无法提供正常服务。

我们为了保证数据的安全，我们引入了replica的概念，跟hdfs里面的概念是一个意思。

可以保证我们数据的安全。

在ES集群中，我们一模一样的数据有多份，能正常提供查询和插入的分片我们叫做 primary shard，其余的我们就管他们叫做 replica shard（备份的分片） 

当我们去查询数据的时候，我们数据是有备份的，它会同时发出命令让我们有数据的机器去查询结果，最后谁的查询结果快，我们就要谁的数据（这个不需要我们去控制，它内部就自己控制了）

总结：
在默认情况下，我们创建一个库的时候，默认会帮我们创建5个主分片（primary shrad）和5个副分片（replica shard），所以说正常情况下是有10个分片的。

同一个节点上面，副本和主分片是一定不会在一台机器上面的，就是拥有相同数据的分片，是不会在同一个节点上面的。

所以当你有一个节点的时候，这个分片是不会把副本存在这仅有的一个节点上的，当你新加入了一台节点，ES会自动的给你在新机器上创建一个之前分片的副本。

3.10 举例

比如一首诗，有诗题、作者、朝代、字数、诗内容等字段，那么首先，我们可以建立一个名叫 Poems 的索引，然后创建一个名叫 Poem 的类型，类型是通过 Mapping 来定义每个字段的类型。

比如诗题、作者、朝代都是 Keyword 类型，诗内容是 Text 类型，而字数是 Integer 类型，最后就是把数据组织成 Json 格式存放进去了。

 Keyword 类型是不会分词的，直接根据字符串内容建立反向索引，Text 类型在存入 Elasticsearch 的时候，会先分词，然后根据分词后的内容建立反向索引。

ES 核心概念

1、索引

2、字段类型（mapping）

3、文档（documents）

概述

在前面的学习中，我们已经掌握了 es 是什么，同时也把 es 的服务已经安装启动，那么 es 是如何去存储数据，数据结构是什么，又是如何实现搜索的呢？我们先来聊聊 ElasticSearch 的相关概念吧！

集群，节点，索引，类型，文档，分片，映射是什么？

elasticsearch 是面向文档，关系行数据库 和 elasticsearch 客观的对比！一切都是 JSON！

Relational DB	Elasticsearch
数据库(database)	索引(indices)
表(tables)	types
行(rows)	documents
字段(columns)	fields

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

物理设计：

elasticsearch 在后台把每个索引划分成多个分片，每分分片可以在集群中的不同服务器间迁移一个人就是一个集群！默认的集群名称就是 elaticsearh

逻辑设计：

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

文档

就是我们的一条条数据

user

1   zhangsan        18

2   kuangshen       3

之前说 elasticsearch 是面向文档的，那么就意味着索引和搜索数据的最小单位是文档，elasticsearch 中，文档有几个 重要属性 :

• 自我包含，一篇文档同时包含字段和对应的值，也就是同时包含 key:value！

• 可以是层次型的，一个文档中包含自文档，复杂的逻辑实体就是这么来的！ {就是一个 json 对象！fastjson 进行自动转换！}

• 灵活的结构，文档不依赖预先定义的模式，我们知道关系型数据库中，要提前定义字段才能使用，在 elasticsearch 中，对于字段是非常灵活的，有时候，我们可以忽略该字段，或者动态的添加一个新的字段。

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

类型

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

索引

就是数据库！

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

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

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

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

倒排索引

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

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

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

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

term	doc_1	doc_2
Study	√	×
To	x	×
every	√	√
forever	√	√
day	√	√
study	×	√
good	√	√
every	√	√
to	√	×
up	√	√

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

term	doc_1	doc_2
to	√	×
forever	√	√
total	2	1

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

再来看一个示例，比如我们通过博客标签来搜索博客文章。那么倒排索引列表就是这样的一个结构 :

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

elasticsearch 的索引和 Lucene 的索引对比

在 elasticsearch 中， 索引 （库）这个词被频繁使用，这就是术语的使用。 在 elasticsearch 中，索引被分为多个分片，每份 分片是一个 Lucene 的索引。所以一个 elasticsearch 索引是由多个 Lucene 索引组成的。别问为什么，谁让 elasticsearch 使用 Lucene 作为底层呢! 如无特指，说起索引都是指 elasticsearch 的索引。

接下来的一切操作都在 kibana 中 Dev Tools 下的 Console 里完成。基础操作！

IK 分词器插件

什么是 IK 分词器？

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

如果要使用中文，建议使用 ik 分词器！

IK 提供了两个分词算法：ik_smart 和 ik_max_word，其中 ik_smart 为最少切分，ik_max_word 为最细粒度划分！一会我们测试！

安装

1、GitHub - medcl/elasticsearch-analysis-ik: The IK Analysis plugin integrates Lucene IK analyzer into elasticsearch, support customized dictionary.

2、下载完毕之后，放入到我们的 elasticsearch 插件即可！
放到plugins中

3、重启观察 ES，可以看到 ik 分词器被加载了！

4、elasticsearch-plugin 可以通过这个命令来查看加载进来的插件
lib目录下开启cmd运行命令elasticsearch-plugin list

5、使用 kibana 测试！

查看不同的分词效果

其中 ik_smart 为最少切分

GET _analyze
{
  "analyzer": "ik_smart",
  "text": "中国共产党"
}

ik_max_word 为最细粒度划分！穷尽词库的可能！字典！

GET _analyze
{
  "analyzer": "ik_max_word",
  "text": "中国共产党"
}

我们输入 超级喜欢狂神说 Java

发现问题：狂神说被拆开了！

GET _analyze
{
  "analyzer": "ik_smart",
  "text": "超级喜欢狂神说 Java"
}

这种自己需要的词，需要自己加到我们的分词器的字典中！

ik 分词器增加自己的配置！

此文件是用于配置自己的词

让我们新建自己的词文件

xml中配置

重启 es，看细节！

再次测试一下狂神说，看下效果！

GET _analyze
{
  "analyzer": "ik_smart",
  "text": "超级喜欢黄佳林学 Java"
}

以后的话，我们需要自己配置 分词就在自己定义的 dic 文件中进行配置即可！

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

关于索引的基本操作

1、创建一个索引！

PUT /索引名/~类型名~/文档id
{请求体}

PUT /test1/type1/1
{
  "name": "狂神说",
  "age": 3
}

超时修改es内存(jvm配置中)，再修改kibana配置，requestTimeOut为90000

完成了自动增加了索引！数据也成功的添加了，这就是我说大家在初期可以把它当做数据库学习的原因！

3、那么 name 这个字段用不用指定类型呢。毕竟我们关系型数据库 是需要指定类型的啊 !

字符串类型

text 、 keyword

数值类型

long, integer, short, byte, double, float, half_float, scaled_float

日期类型

date

te 布尔值类型

boolean

二进制类型

binary

等等…

4、指定字段的类型

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

获得这个规则！ 可以通过 GET 请求获取具体的信息！

GET test2

5、查看默认的信息

PUT /test3/_doc/1
{
  "name": "狂神说",
  "age": 3,
  "birthday": "1998-08-25"
}

如果自己的文档字段没有指定，那么 es 就会给我们默认配置字段类型！

GET test3

扩展： 通过命令 elasticsearch 索引情况！ 通过 get _cat/ 可以获得 es 的当前的很多信息！

GET _cat/health

修改 提交还是使用 PUT 即可！ 然后覆盖！最新办法！

曾经！

PUT /test3/_doc/1
{
  "name": "狂神说123",
  "age": 3,
  "birthday": "1998-08-25"
}

现在的方法！

POST /test3/_doc/1/_update
{
  "doc": {
    "name": "法外狂徒张三"
  }
}

弹幕:POST/{index}/_update/{id} 这个是最新的语法

POST /test3/_update/1
{
  "doc": {
    "name": "法外狂徒张三2"
  }
}

删除索引！

通过 DELETE 命令实现删除、 根据你的请求来判断是删除索引还是删除文档记录！

DELETE test1

使用 RESTFUL 风格是我们 ES 推荐大家使用的！

关于文档的基本操作（重点）

基础操作（增改查）

1、添加数据

PUT /kuangshen/user/1
{
	"name": "狂神说",
	"age": 23,
	"desc": "一顿操作猛如虎，一看工资2500",
	"tags": ["技术宅","温暖","直男"]
}

再添加两个数据

PUT /kuangshen/user/2
{
	"name": "张三",
	"age": 3,
	"desc": "法外狂徒",
	"tags": ["交友","旅游","渣男"]
}

PUT /kuangshen/user/3
{
	"name": "李四",
	"age": 30,
	"desc": "逍遥自在",
	"tags": ["靓仔","大餐","编程"]
}

2、获取数据 GET

GET  kuangshen/user/1

3、更新数据 PUT

PUT /kuangshen/user/3
{
	"name": "李四233",
	"age": 30,
	"desc": "逍遥自在",
	"tags": ["靓仔","大餐","编程"]
}

4、POST _update , 推荐使用这种更新方式！

POST /kuangshen/_update/1
{
  "doc": {
    "name": "狂神说Java"
  }
}

简单地搜索！

GET kuangshen/user/1

简答的条件查询，可以根据默认的映射规则，产生基本的查询！

GET  kuangshen/user/_search?q=name:狂神说Java

复杂操作搜索 select ( 排序，分页，高亮，模糊查询，精准查询！)

GET  kuangshen/user/_search
{
  "query": {
    "match": {
      "name": "狂神"
    }
  }
}

再加入一条数据

PUT /kuangshen/user/4
{
	"name": "狂神说前端",
	"age": 3,
	"desc": "一顿操作猛如虎，一看工资2500",
	"tags": ["技术宅","温暖","直男"]
}

GET  kuangshen/user/_search
{
  "query": {
    "match": {
      "name": "狂神"
    }
  }
}

输出结果，不想要那么多！

GET  kuangshen/user/_search
{
  "query": {
    "match": {
      "name": "狂神"
    }
  },
  "_source": ["name","desc"]
}

我们之后使用 Java 操作 es ，所有的方法和对象就是这里面的 key！

排序！

GET  kuangshen/user/_search
{
  "query": {
    "match": {
      "name": "狂神"
    }
  },
  "sort": [
    {
      "age": {
        "order": "desc"
      }
    }
  ]
}

分页查询！

GET  kuangshen/user/_search
{
  "query": {
    "match": {
      "name": "狂神"
    }
  },
  "sort": [
    {
      "age": {
        "order": "desc"
      }
    }
  ],
  "from": 0,
  "size": 1
}

数据下标还是从 0 开始的，和学的所有数据结构是一样的！

/search/{current}/{pagesize}

布尔值查询

must （and），所有的条件都要符合 where id = 1 and name = xxx

GET  kuangshen/user/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "name": "狂神说"
          }
        },{
          "match": {
            "age": 3
          }
        }
      ]
    }
  }
}

should（or），所有的条件都要符合where id = 1 or name = xxx

GET  kuangshen/user/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "match": {
            "name": "狂神说"
          }
        },{
          "match": {
            "age": 3
          }
        }
      ]
    }
  }
}

must_not （not）

GET  kuangshen/user/_search
{
  "query": {
    "bool": {
      "must_not": [
        {
          "match": {
            "age": 23
          }
        }
      ]
    }
  }
}

过滤器 filter

GET  kuangshen/user/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "name": "狂神说"
          }
        }
      ],
      "filter": {
        "range": {
          "age": {
            "gte": 10,
            "lte": 30
          }
        }
      }
    }
  }
}

• gt 大于

• gte 大于等于

• lt 小于

• lte 小于等于！
  

匹配多个条件！

GET  kuangshen/user/_search
{
  "query": {
    "match": {
      "tags": "男 技术"
    }
  }
}

精确查询！

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

关于分词：

• term ，直接查询精确的

• match，会使用分词器解析！（先分析文档，然后在通过分析的文档进行查询！）

两个类型 text keyword

新建一个数据库

PUT testdb
{
  "mappings": {
    "properties": {
      "name": {
        "type": "text"
      },
      "desc": {
        "type": "keyword"
      }
    }
  }
}

添加数据

PUT testdb/_doc/1
{
  "name": "狂神说Java name",
  "desc": "狂神说Java desc"
}

PUT testdb/_doc/2
{
  "name": "狂神说Java name",
  "desc": "狂神说Java desc2"
}

分词查看

GET _analyze
{
  "analyzer": "keyword",
  "text": ["狂神说Java name"]
}

GET _analyze
{
  "analyzer": "standard",
  "text": ["狂神说Java name"]
}

查询数据

GET testdb/_search
{
  "query": {
    "term": {
      "name": "狂"
    }
  }
}

GET testdb/_search
{
  "query": {
    "term": {
      "desc": "狂神说Java desc"
    }
  }
}

多个值匹配精确查询

添加数据

PUT testdb/_doc/3
{
  "t1": "22",
  "t2": "2020-4-6"
}

PUT testdb/_doc/4
{
  "t1": "33",
  "t2": "2020-4-7"
}

查询

GET testdb/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "term": {
              "t1": "22"
          }
        },{
          "term": {
              "t1": "33"
          }
        }
      ]
    }
  }
}

高亮查询！

GET testdb/_search
{
  "query": {
    "match": {
      "name": "狂神"
    }
  },
  "highlight": {
    "fields": {
      "name": {}
    }
  }
}

GET testdb/_search
{
  "query": {
    "match": {
      "name": "狂神"
    }
  },
  "highlight": {
    "pre_tags": "<span class='key' style='color:red'>", 
    "post_tags": "</span>", 
    "fields": {
      "name": {}
    }
  }
}

这些其实 MySQL 也可以做，只是 MySQL 效率比较低！

回顾

• 匹配

• 按照条件匹配

• 精确匹配

• 区间范围匹配

• 匹配字段过滤

• 多条件查询

• 高亮查询

集成 SpringBoot

找官方文档！

• 文档连接 Elastic Stack and Product Documentation | Elastic

1、找到原生的依赖

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

2、找对象

3、分析这个类中的方法即可！

配置基本的项目

项目创建

• 先创建一个空项目
• 然后在空项目中创建一个模块
  
  

创建完成之后

• 加JDK
  
• 改版本
  
• maven仓库
  
• 改版本
  
• 改编码
  

问题：一定要保证 我们的导入的依赖和我们的 es 版本一致

查看版本

	<properties>
		<java.version>1.8</java.version>
		<!--自定义es版本依赖,保证和本地一样-->
		<elasticsearch.version>7.6.1</elasticsearch.version>
	</properties>

源码中提供对象！

ElasticSearchClientConfig

package com.huang.config;

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

//狂神Spring两步骤
//1.找对象
//2.放到Spring中待用
//3.如果是SpringBoot就分析一波源码
//XXXAutoConfiguration XXXProperties
@Configuration
public class ElasticSearchClientConfig {

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

虽然这里导入 3 个类，静态内部类，核心类就一个！

/*
 * Copyright 2012-2019 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.springframework.boot.autoconfigure.elasticsearch.rest;

import java.time.Duration;

import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.Credentials;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import
        org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.PropertyMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Elasticsearch rest client infrastructure configurations.
 *
 * @author Brian Clozel
 * @author Stephane Nicoll
 */
class RestClientConfigurations {
    @Configuration(proxyBeanMethods = false)
    static class RestClientBuilderConfiguration {
        //  RestClientBuilder
        @Bean
        @ConditionalOnMissingBean
        RestClientBuilder elasticsearchRestClientBuilder(RestClientProperties properties,
                                                         ObjectProvider<RestClientBuilderCustomizer> builderCustomizers) {
            HttpHost[] hosts = properties.getUris().stream().map(HttpHost::create).toArray(HttpHost[]::new);
            RestClientBuilder builder = RestClient.builder(hosts);
            PropertyMapper map = PropertyMapper.get();
            map.from(properties::getUsername).whenHasText().to((username) -> {
                CredentialsProvider credentialsProvider = new
                        BasicCredentialsProvider();
                Credentials credentials = new
                        UsernamePasswordCredentials(properties.getUsername(),
                        properties.getPassword());
                credentialsProvider.setCredentials(AuthScope.ANY, credentials);
                builder.setHttpClientConfigCallback(
                        (httpClientBuilder) ->
                                httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider));
            });
            builder.setRequestConfigCallback((requestConfigBuilder) -> {

                map.from(properties::getConnectionTimeout).whenNonNull().asInt(Duration::toMill
                        is)
                        .to(requestConfigBuilder::setConnectTimeout);

                map.from(properties::getReadTimeout).whenNonNull().asInt(Duration::toMillis)
                        .to(requestConfigBuilder::setSocketTimeout);
                return requestConfigBuilder;
            });
            builderCustomizers.orderedStream().forEach((customizer) ->
                    customizer.customize(builder));
            return builder;
        }
    }

    @Configuration(proxyBeanMethods = false)
    @ConditionalOnClass(RestHighLevelClient.class)
    static class RestHighLevelClientConfiguration {
        //  RestHighLevelClient  高级客户端，也是我们这里要讲，后面项目会用到的客户端
        @Bean
        @ConditionalOnMissingBean
        RestHighLevelClient elasticsearchRestHighLevelClient(RestClientBuilder
                                                                     restClientBuilder) {
            return new RestHighLevelClient(restClientBuilder);
        }

        @Bean
        @ConditionalOnMissingBean
        RestClient elasticsearchRestClient(RestClientBuilder builder,
                                           ObjectProvider<RestHighLevelClient> restHighLevelClient) {
            RestHighLevelClient client = restHighLevelClient.getIfUnique();
            if (client != null) {
                return client.getLowLevelClient();
            }
            return builder.build();
        }
    }

    @Configuration(proxyBeanMethods = false)
    static class RestClientFallbackConfiguration {
        // RestClient 普通的客户端！
        @Bean
        @ConditionalOnMissingBean
        RestClient elasticsearchRestClient(RestClientBuilder builder) {
            return builder.build();
        }
    }
}

集成springboot后具体的 Api 测试！

1、创建索引

    // 测试索引的创建  Request  PUT kuang_index
    @Test
    void testCreateIndex() throws IOException {
        // 1、创建索引请求
        CreateIndexRequest request = new CreateIndexRequest("kuang_index");
        // 2、客户端执行请求 IndicesClient,请求后获得响应
        CreateIndexResponse createIndexResponse =
                client.indices().create(request, RequestOptions.DEFAULT);
        System.out.println(createIndexResponse);
    }

2、判断索引是否存在

    //测试获取索引
    @Test
    void testExistIndex() throws IOException{
        GetIndexRequest request = new GetIndexRequest("kuang_index");
        boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
        System.out.println(exists);
    }

3、删除索引

    // 测试删除索引
    @Test
    void testDeleteIndex() throws IOException {
        DeleteIndexRequest request = new DeleteIndexRequest("kuang_index");
        //删除
        AcknowledgedResponse delete = client.indices().delete(request, RequestOptions.DEFAULT);
        System.out.println(delete.isAcknowledged());

    }

4、创建文档

首先创建一个User实体类

package com.huang.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Component
public class User {
    private String name;
    private int age;
}

导入依赖

		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.74</version>
		</dependency>

    //测试添加文档
    @Test
    void testAddDocument() throws IOException {
        //创建对象
        User user = new User("狂神说", 3);
        //创建请求
        IndexRequest request = new IndexRequest("kuang_index");
        //规则 put /kuang_index/_doc/1
        request.id("1");
        request.timeout(TimeValue.timeValueSeconds(1));
        request.timeout("1s");
        // 将我们的数据放入请求  json
        request.source(JSON.toJSONString(user), XContentType.JSON);
        // 客户端发送请求 , 获取响应的结果
        IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);

        System.out.println(indexResponse.toString());//数据
        System.out.println(indexResponse.status());// 对应我们命令返回的状态CREATED
    }

5、判断文档是否存在

    // 获取文档，判断是否存在 get /index/doc/1
    @Test
    void testIsExists() throws IOException {
        GetRequest getRequest = new GetRequest("kuang_index", "1");
        // 不获取返回的 _source 的上下文了
        getRequest.fetchSourceContext(new FetchSourceContext(false));
        getRequest.storedFields("_none_");

        boolean exists = client.exists(getRequest, RequestOptions.DEFAULT);
        System.out.println(exists);
    }

6、获取文档信息

    // 获得文档的信息
    @Test
    void testGetDocument() throws IOException {
        GetRequest getRequest = new GetRequest("kuang_index", "1");
        GetResponse getResponse = client.get(getRequest,RequestOptions.DEFAULT);
        System.out.println(getResponse.getSourceAsString()); // 打印文档的内容
        System.out.println(getResponse); // 返回的全部内容和命令式一样的
    }

7、更新文档的信息

    // 更新文档的信息
    @Test
    void testUpdateRequest() throws IOException {
        UpdateRequest request = new UpdateRequest("kuang_index","1");
        request.timeout("1s");

        User user = new User("狂神说Java", 18);
        request.doc(JSON.toJSONString(user),XContentType.JSON);

        UpdateResponse update = client.update(request, RequestOptions.DEFAULT);
        System.out.println(update.status());
    }

8、删除文档记录

    // 删除文档记录
    @Test
    void testDeleteRequest() throws IOException {
        DeleteRequest request = new DeleteRequest("kuang_index","1");
        request.timeout("1s");
        DeleteResponse deleteResponse = client.delete(request,
                RequestOptions.DEFAULT);
        System.out.println(deleteResponse.status());
    }

9、特殊的，真的项目一般都会批量插入数据！

    // 特殊的，真的项目一般都会批量插入数据！
    @Test
    void testBulkRequest() throws IOException {
        BulkRequest bulkRequest = new BulkRequest();
        bulkRequest.timeout("10s");

        List<User> userList = new ArrayList<>();
        userList.add(new User("kuangshen1",20));
        userList.add(new User("kuangshen2",21));
        userList.add(new User("kuangshen3",22));
        userList.add(new User("kuangshen4",23));
        userList.add(new User("kuangshen5",24));

        //批量处理数据
        for (int i = 0; i < userList.size(); i++) {
            //批量删除和修改就在这里操作
            bulkRequest.add(
                    new IndexRequest("kuang_index")
                    .id(""+(i+1))
                    .source(JSON.toJSONString(userList.get(i)),XContentType.JSON)
            );
        }
        BulkResponse bulk = client.bulk(bulkRequest, RequestOptions.DEFAULT);
        System.out.println(bulk.hasFailures());//是否执行失败
    }

10、查询

    // 查询
    // SearchRequest 搜索请求
    // SearchSourceBuilder 条件构造
    //  HighlightBuilder 构建高亮
    //  TermQueryBuilder 精确查询
    //  MatchAllQueryBuilder
    //  xxx QueryBuilder 对应我们刚才看到的命令！

    @Test
    void testSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("kuang_index");
        //构建搜索条件
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        
        //查询条件,我们可以使用SearchSourceBuilder工具来实现

        //精确匹配QueryBuilders.termQuery()
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name", "kuangshen1");
        sourceBuilder.query(termQueryBuilder);
        sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));

        searchRequest.source(sourceBuilder);

        SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
        System.out.println(JSON.toJSONString(searchResponse));
        System.out.println("+++++++++++++++++++++++++++++++++++++++++");
        for (SearchHit hit : searchResponse.getHits()) {
            System.out.println(hit.getSourceAsMap());
        }
    }

合集

package com.kuang;
import com.alibaba.fastjson.JSON;
import com.kuang.pojo.User;
import com.kuang.utils.ESconst;
import com.sun.corba.se.spi.activation.ServerAlreadyRegistered;
import lombok.SneakyThrows;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.MatchAllQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchPhase;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;
import sun.reflect.ReflectionFactory;
import java.io.IOException;
import java.util.ArrayList;
import java.util.concurrent.TimeUnit;
import java.util.function.Predicate;
/**
 * 狂神讲解 es7.6.x 高级客户端测试 API
 */
@SpringBootTest
class KuangshenEsApiApplicationTests {
    // 面向对象来操作
    @Autowired
    @Qualifier("restHighLevelClient")
    private RestHighLevelClient client;
       // 测试索引的创建  Request  PUT kuang_index
    @Test
    void testCreateIndex() throws IOException {
        // 1、创建索引请求
        CreateIndexRequest request = new CreateIndexRequest("kuang_index");
        // 2、客户端执行请求 IndicesClient,请求后获得响应
        CreateIndexResponse createIndexResponse =
                client.indices().create(request, RequestOptions.DEFAULT);
        System.out.println(createIndexResponse);
    }
    // 测试获取索引,判断其是否存在
    @Test
    void testExistIndex() throws IOException {
        GetIndexRequest request = new GetIndexRequest("kuang_index2");
        boolean exists = client.indices().exists(request, 
RequestOptions.DEFAULT);
        System.out.println(exists);
    }
    // 测试删除索引
    @Test
    void testDeleteIndex() throws IOException {
        DeleteIndexRequest request = new DeleteIndexRequest("kuang_index");
        // 删除
        AcknowledgedResponse delete = client.indices().delete(request, 
RequestOptions.DEFAULT);
        System.out.println(delete.isAcknowledged());
    }
    // 测试添加文档
    @Test
    void testAddDocument() throws IOException {
        // 创建对象
        User user = new User("狂神说", 3);
        // 创建请求
        IndexRequest request = new IndexRequest("kuang_index");
        // 规则 put /kuang_index/_doc/1
        request.id("1");
        request.timeout(TimeValue.timeValueSeconds(1));
        request.timeout("1s");
        // 将我们的数据放入请求  json
        request.source(JSON.toJSONString(user), XContentType.JSON);
        // 客户端发送请求 , 获取响应的结果
        IndexResponse indexResponse = client.index(request, 
RequestOptions.DEFAULT);
        System.out.println(indexResponse.toString()); //
        System.out.println(indexResponse.status()); // 对应我们命令返回的状态 CREATED
    }
    // 获取文档，判断是否存在 get /index/doc/1
    @Test
       void testIsExists() throws IOException {
        GetRequest getRequest = new GetRequest("kuang_index", "1");
        // 不获取返回的 _source 的上下文了
        getRequest.fetchSourceContext(new FetchSourceContext(false));
        getRequest.storedFields("_none_");
        boolean exists = client.exists(getRequest, RequestOptions.DEFAULT);
        System.out.println(exists);
    }
    // 获得文档的信息
    @Test
    void testGetDocument() throws IOException {
        GetRequest getRequest = new GetRequest("kuang_index", "1");
        GetResponse getResponse = client.get(getRequest, 
RequestOptions.DEFAULT);
        System.out.println(getResponse.getSourceAsString()); // 打印文档的内容
        System.out.println(getResponse); // 返回的全部内容和命令式一样的
    }
    // 更新文档的信息
    @Test
    void testUpdateRequest() throws IOException {
        UpdateRequest updateRequest = new UpdateRequest("kuang_index","1");
        updateRequest.timeout("1s");
        User user = new User("狂神说Java", 18);
        updateRequest.doc(JSON.toJSONString(user),XContentType.JSON);
        UpdateResponse updateResponse = client.update(updateRequest, 
RequestOptions.DEFAULT);
        System.out.println(updateResponse.status());
    }
    // 删除文档记录
    @Test
    void testDeleteRequest() throws IOException {
        DeleteRequest request = new DeleteRequest("kuang_index","1");
        request.timeout("1s");
        DeleteResponse deleteResponse = client.delete(request, 
RequestOptions.DEFAULT);
        System.out.println(deleteResponse.status());
    }
    // 特殊的，真的项目一般都会批量插入数据！
    @Test
    void testBulkRequest() throws IOException {
        BulkRequest bulkRequest = new BulkRequest();
        bulkRequest.timeout("10s");
        ArrayList<User> userList = new ArrayList<>();
        userList.add(new User("kuangshen1",3));
        userList.add(new User("kuangshen2",3));
        userList.add(new User("kuangshen3",3));
        userList.add(new User("qinjiang1",3));
        userList.add(new User("qinjiang1",3));
        userList.add(new User("qinjiang1",3));
               // 批处理请求
        for (int i = 0; i < userList.size() ; i++) {
            // 批量更新和批量删除，就在这里修改对应的请求就可以了
            bulkRequest.add(
                    new IndexRequest("kuang_index")
                    .id(""+(i+1))
                    
.source(JSON.toJSONString(userList.get(i)),XContentType.JSON));
        }
        BulkResponse bulkResponse = client.bulk(bulkRequest, 
RequestOptions.DEFAULT);
        System.out.println(bulkResponse.hasFailures()); // 是否失败，返回 false 代表成功！
    }
    // 查询
    // SearchRequest 搜索请求
    // SearchSourceBuilder 条件构造
    //  HighlightBuilder 构建高亮
    //  TermQueryBuilder 精确查询
    //  MatchAllQueryBuilder 
    //  xxx QueryBuilder 对应我们刚才看到的命令！
    
    @Test
    void testSearch() throws IOException {
        SearchRequest searchRequest = new SearchRequest("kuang_index");
        // 构建搜索条件
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.highlighter()
        // 查询条件，我们可以使用 QueryBuilders 工具来实现
        // QueryBuilders.termQuery 精确
        // QueryBuilders.matchAllQuery() 匹配所有
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name", 
"qinjiang1");
//        MatchAllQueryBuilder matchAllQueryBuilder = 
QueryBuilders.matchAllQuery();
        sourceBuilder.query(termQueryBuilder);
        sourceBuilder.timeout(new TimeValue(60,TimeUnit.SECONDS));
        searchRequest.source(sourceBuilder);
        SearchResponse searchResponse = client.search(searchRequest, 
RequestOptions.DEFAULT);
        System.out.println(JSON.toJSONString(searchResponse.getHits()));
        System.out.println("=================================");
        for (SearchHit documentFields : searchResponse.getHits().getHits()) {
            System.out.println(documentFields.getSourceAsMap());
        }
    }
    
}

实战

准备工作

新建一个项目

	<properties>
		<java.version>1.8</java.version>
		<!--自定义es版本依赖,保证和本地一样-->
		<elasticsearch.version>7.6.1</elasticsearch.version>
	</properties>

		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.74</version>
		</dependency>

配置application.properties

server.port=9090
#关闭thymeleaf的缓存
spring.thymeleaf.cache=false

获取资料

粘贴到

编写IndexController

package com.huang.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class IndexController {

    @RequestMapping({"/","/index"})
    public String index(){
        return "index";
    }
}

启动测试

优质博客：（工作中一般使用EsUtil进行操作）

Springboot 集成 Elasticsearch 详解 2.5.7的springboot对应7.12.1的es版本