【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战


☀️☀️你好啊!小伙伴,我是小冷。是一个兴趣驱动自学练习两年半的的Java工程师。
一位十分喜欢将知识分享出来的Java博主⭐️⭐️⭐️,擅长使用Java技术开发web项目和工具
文章内容丰富:覆盖大部分java必学技术栈,前端,计算机基础,容器等方面的文章
如果你也对Java感兴趣,关注小冷吧,一起探索Java技术的生态与进步,一起讨论Java技术的使用与学习
✏️高质量技术专栏专栏链接: 微服务数据结构netty,单点登录,SSMSpringCloudAlibaba
公众号想全栈的小冷,分享一些技术上的文章,以及解决问题的经验
当前专栏搜索引擎系列
专栏代码地址: ES-京东
专栏代码地址: ES-API

Elasticsearch

我们搜做 : 冷环渊,可以看到有关冷环渊的一些信息,

那么这个是怎么做到的呢?,往常我们都是用

SQL : like %冷环渊% 但是数据量一旦变大了,就会变慢,这个时候用索引, 也是只能快一些

这个时候 Elasticsearch就是帮助我们解决问题的关键人物

他专注于搜索 : 百度,github,淘宝等搜索都能看到他的影子

我们下面会通过以下去完成对es的学习

  1. 认识一个人
  2. 看看同种类的搜索引擎的区别
  3. 安装
  4. 生态圈
  5. IK 分词器
  6. RestFul 操作
  7. RestFul CRUD
  8. SpingBoot 继承 ES(从原理开始分析)
  9. 实战 : 爬虫爬取数据!
  10. 模拟全文检索

以后只要,需要用到搜索,就可以使用ES , 建议基于大数据的情况下

聊聊这个人 Doug Cutting

1998年9月4日,Google公司在美国硅谷成立。正如大家所知,它是一家做搜索引擎起家的公司。

学大数据 首先就是 hadoop

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第1张图片

无独有偶,一位名叫Doug Cutting的美国工程师,也迷上了搜索引擎。他做了一个用于文本搜索的函数库(姑且理解为软件的功能组件),命名为Lucene

图片

左为Doug Cutting,右为Lucene的LOGO

Lucene是用JAVA写成的,目标是为各种中小型应用软件加入全文检索功能。因为好用而且开源(代码公开),非常受程序员们的欢迎。

早期的时候,这个项目被发布在Doug Cutting的个人网站和SourceForge(一个开源软件网站)。后来,2001年底,Lucene成为Apache软件基金会jakarta项目的一个子项目。

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第2张图片

Apache软件基金会,搞IT的应该都认识

2004年,Doug Cutting再接再励,在Lucene的基础上,和Apache开源伙伴Mike Cafarella合作,开发了一款可以代替当时的主流搜索的开源搜索引擎,命名为Nutch

图片

Nutch是一个建立在Lucene核心之上的网页搜索应用程序,可以下载下来直接使用。它在Lucene的基础上加了网络爬虫和一些网页相关的功能,目的就是从一个简单的站内检索推广到全球网络的搜索上,就像Google一样。

Nutch在业界的影响力比Lucene更大。

大批网站采用了Nutch平台,大大降低了技术门槛,使低成本的普通计算机取代高价的Web服务器成为可能。甚至有一段时间,在硅谷有了一股用Nutch低成本创业的潮流。

随着时间的推移,无论是Google还是Nutch,都面临搜索对象“体积”不断增大的问题。

尤其是Google,作为互联网搜索引擎,需要存储大量的网页,并不断优化自己的搜索算法,提升搜索效率。

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第3张图片

Google搜索栏

在这个过程中,Google确实找到了不少好办法,并且无私地分享了出来。

2003年,Google发表了一篇技术学术论文,公开介绍了自己的谷歌文件系统GFS(Google File System)。这是Google公司为了存储海量搜索数据而设计的专用文件系统。

第二年,也就是2004年,Doug Cutting基于Google的GFS论文,实现了分布式文件存储系统,并将它命名为NDFS(Nutch Distributed File System)

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第4张图片

还是2004年,Google又发表了一篇技术学术论文,介绍自己的MapReduce编程模型。这个编程模型,用于大规模数据集(大于1TB)的并行分析运算。

第二年(2005年),Doug Cutting又基于MapReduce,在Nutch搜索引擎实现了该功能。

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第5张图片

2006年,当时依然很厉害的Yahoo(雅虎)公司,招安了Doug Cutting。

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第6张图片

这里要补充说明一下雅虎招安Doug的背景:2004年之前,作为互联网开拓者的雅虎,是使用Google搜索引擎作为自家搜索服务的。在2004年开始,雅虎放弃了Google,开始自己研发搜索引擎。所以。。。

加盟Yahoo之后,Doug Cutting将NDFS和MapReduce进行了升级改造,并重新命名为Hadoop(NDFS也改名为HDFS,Hadoop Distributed File System)。

这个,就是后来大名鼎鼎的大数据框架系统——Hadoop的由来。而Doug Cutting,则被人们称为Hadoop之父

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第7张图片

Hadoop这个名字,实际上是Doug Cutting他儿子的黄色玩具大象的名字。所以,Hadoop的Logo,就是一只奔跑的黄色大象。

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第8张图片

我们继续往下说。

还是2006年,Google又发论文了。

这次,它们介绍了自己的BigTable。这是一种分布式数据存储系统,一种用来处理海量数据的非关系型数据库。

Doug Cutting当然没有放过,在自己的hadoop系统里面,引入了BigTable,并命名为HBase

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第9张图片

好吧,反正就是紧跟Google时代步伐,你出什么,我学什么。

所以,Hadoop的核心部分,基本上都有Google的影子。

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第10张图片

2008年1月,Hadoop成功上位,正式成为Apache基金会的顶级项目。

同年2月,Yahoo宣布建成了一个拥有1万个内核的Hadoop集群,并将自己的搜索引擎产品部署在上面。

7月,Hadoop打破世界纪录,成为最快排序1TB数据的系统,用时209秒。

此后,Hadoop便进入了高速发展期,直至现在。

回到主题

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

包含 : 索引结构,读写索引工具 排序,搜索规则 。。。 工具类

Lucene 和 ES 的关系:

ES 是居于 Lucene 做了封装和增强 (我们上手就会感到十分的简单)

ElasticSearch概述

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

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

关键字就是:

  • 实时
  • 分布式
  • 大数据
  • 速度快

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™的开源搜索引擎。无论在开源还是专有领域,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引擎。

2.4 Elasticsearch和Solr比较

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第11张图片

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第12张图片

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第13张图片

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第14张图片

2.5 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相对开发维护者较少,更新太快,学习使用成本较高。(趋势!)

ElasticSearch 安装

就注意一点,JDK必须不能低于 1.8 最低要求就是1.8

因为是java开发的,所以ES的版本和我们之后对应的java的和jar包的版本必须对应,且要保证JDK环境是正常的

下载

官网地址 :https://www.elastic.co/cn/elasticsearch/

之后解压

查看目录

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第15张图片

熟悉目录

bin 启动文件
config 配置文件
	log4j2 日志文件
	jvm.options jvm的运行参数,内存不足的一定要调整,默认是1g
	elasticsearch ES的一些配置 默认 : 9200
lib      相关架构
logs     日志!
modules  功能模块
pluginx  插件 

启动查看

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第16张图片

访问查看

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第17张图片

安装可视化界面 ES head 插件

下载地址 : https://github.com/mobz/elasticsearch-head

之后 配置环境和启动测试

npm install 
npm run start

之后启动查看 9100端口

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第18张图片

但是发现,迟迟连接不上,这个是为什么? 跨域问题,端口和端口的访问,于是我们要去配置ES的快去权限开启

http.cors.enabled: ture
http.cors.allow-origin: "*"

之后重启es,连接成功

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第19张图片

我们可以创建索引体验一下,我们可以把索引,我们可以暂时当作是一个数据库(索引(库),表(库中的数据)),7.x之后就淘汰了表,这个我们之后的学习就可以了解到哈哈

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第20张图片

创建索引查看

这个head就当作我们展示数据的工具

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第21张图片

这里面的json是没有格式化的,我们后续用kabanna做

了解 ELK

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

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

安装Kibana

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

日志数据清洗 —> 搜索,存储 —> 展示

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第22张图片

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

安装注意 : klbanna 要和 ES 的版本要一致

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第23张图片

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

好处 ELK基本上都是拆箱就可以用了

启动测试

查看解压目录

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第24张图片

启动

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第25张图片

访问 5601看看i情况

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第26张图片

开发工具 Post curl head 谷歌插件

之后我们的命令就在这个klbanna里面

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第27张图片

这个时候,全英文就让我们很难受,klbanna也提供了国际化,这个项目十分的优秀

配置汉化

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第28张图片

之后重启klbanna就可以了

ES核心概念

  1. 索引
  2. 字段类型(mapping)
  3. 文档(documents)

概述

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

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

一切都是json

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

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

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

物理设计:

elasticsearch 在后台把每个索引划分成多个分片,每分分片可以在集群中的不同服务器间迁移

一个人就是一个集群!默认的集群名称就是 elaticsearh

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第29张图片

逻辑设计:

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

文档

就是我们的一条条数据

user
1  zhangsan  18
2  kuangshen  3

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

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

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

类型

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第30张图片

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

索引

就是数据库!

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

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

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第31张图片

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

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第32张图片

上图是一个有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 x
To x x
every
forever
day
study x
good
every
to x
up

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

term doc_1 doc_2
to ×
forever
total 2 1

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

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

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第33张图片

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

elasticsearch的索引和Lucene的索引对比

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

IK分词器插件

什么是IK分词器?

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

如果要使用中文,建议使用ik分词器!

IK提供了两个分词算法:ik_smart 和 ik_max_word,其中 ik_smart 为最少切分,ik_max_word为最细粒度划分!

安装

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

  2. 下载完毕之后,放入到我们的elasticsearch 插件即可!

    【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第34张图片

  3. 重启观察ES,可以看到ik分词器被加载了!

    【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第35张图片

  4. elasticsearch-plugin 可以通过这个命令来查看加载进来的插件

    img

  5. 使用kibana测试!

查看不同的分词效果

其中 ik_smart 为最少切分

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第36张图片

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

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第37张图片

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

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第38张图片

发现问题:狂神说被拆开了!

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

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

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第39张图片

重启es,看细节!

img

再次测试一下狂神说,看下效果!

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第40张图片

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 查询所有数据

关于索引的基本操作

创建一个索引!

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

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第41张图片

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

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第42张图片

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

  • 字符串类型
    text 、 keyword
  • 数值类型
    long, integer, short, byte, double, float, half_float, scaled_float
  • 日期类型
    date
  • 布尔值类型
    boolean
  • 二进制类型
    binary
  • 等等…

指定字段的类型

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第43张图片

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

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第44张图片

查看默认的信息

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第45张图片

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第46张图片

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

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

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第47张图片

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

曾经!

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第48张图片

现在的方法!

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第49张图片

删除索引!

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

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

8. 关于文档的基本操作(重点)

基本操作

添加数据

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

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第50张图片

获取数据 GET

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第51张图片

更新数据 PUT

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第52张图片

Post _update , 推荐使用这种更新方式!

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第53张图片

简单地搜索!

GET kuangshen/user/1

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

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第54张图片

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第55张图片

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

img

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第56张图片

输出结果,不想要那么多!

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第57张图片

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

排序!

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第58张图片

分页查询!

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第59张图片

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

/search/{current}/{pagesize}

布尔值查询

must (and),所有的条件都要符合 where id = 1 and name = xxx

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第60张图片

should(or),所有的条件都要符合 where id = 1 or name = xxx

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第61张图片

must_not (not)

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第62张图片

过滤器 filter

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第63张图片

  • gt 大于
  • gte 大于等于
  • lt 小于
  • lte 小于等于!

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第64张图片

匹配多个条件!

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第65张图片

精确查询!

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

关于分词:

  • term ,直接查询精确的
  • match,会使用分词器解析!(先分析文档,然后在通过分析的文档进行查询!)

两个类型 text keyword

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第66张图片

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第67张图片

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第68张图片

多个值匹配精确查询

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第69张图片

高亮查询!

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第70张图片

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第71张图片

使用的命令

PUT /test1/type1/1
{
  "name" : "小冷",
  "age" : 3
}

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

GET test2

PUT /test3/_doc/1
{
  "name": "",
  "age":8,
  "brith":"2004-02-08"
}

POST /test3/_doc/1/_update
{
  "doc":{
    "name": "小冷"
  }
}
GET test3

PUT /lhy/user/1
{
 "name": "狂神说",
 "age": 23,
 "desc": "一顿操作猛如虎,一看工资2500",
 "tags": ["技术宅","温暖","直男"]
}
PUT /lhy/user/2
{
 "name": "法外狂徒张三",
 "age": 30,
 "desc": "罗老师手下的得力干将",
 "tags": ["身体好","懂法律","难判刑"]
}

PUT /lhy/user/2
{
 "name": "法外狂徒张三",
 "age": 19,
 "desc": "罗老师手下的得力干将",
 "tags": ["身体好","懂法律","难判刑"]
}

POST /lhy/user/2/_update
{
  "doc":{
     "name": "张三"
  }
}

PUT /lhy/user/3
{
 "name": "狂神说前端",
 "age": 23,
 "desc": "前端特效大杀手",
 "tags": ["游戏强","抗压强","007"]
}


GET /lhy/user/2

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

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

#boolean
GET lhy/user/_search
{
"query":{
  "bool":{
    "should": [
      {
        "match": {
          "name": "狂神说"
        }
      },
      {
        "match": {
          "age": 23
        }
      }
    ]
  }
}
}
#没有什么,相当与 not 
GET lhy/user/_search
{
"query":{
  "bool":{
    "must_not": [
      {
        "match": {
          "name": "狂神说"
        }
      }
    ]
  }
}
}
#过滤器filter 筛选
GET lhy/user/_search
{
"query":{
  "bool":{
    "must": [
      {
        "match": {
          "name": "狂神说"
        }
      }
    ],
    "filter": [
      {
        "range": {
          "age": {
              "lt": 20
          }
        }
      }
    ]
  }
}
}

GET lhy/user/_search
{
"query":{
  "bool":{
    "must": [
      {
        "match": {
          "tags": "技术 男 身体 007"
        }
      }
    ]
  }
}
}

#精确查询和text keyword 两种类型的细节
PUT testdb
{
  "mappings": {
    "properties": {
      "name":{
        "type": "text"
      },
      "desc":{
        "type": "keyword"
      }
    }
  }
}

PUT testdb/_doc/1
{
  "name":"小冷学java",
  "desc":"java真的是个好玩的语言"
}
PUT testdb/_doc/2
{
  "name":"小冷学java",
  "desc":"java真的是个好玩的语言2"
}

GET _analyze
{
  "analyzer": "keyword" ,
  "text": "小冷"
}
  
GET _analyze
{
  "analyzer": "standard" ,
  "text": "小冷"
}

GET testdb/_search
{
  "query": {
    "term": {
        "desc": "java真的是个好玩的语言"
    }
  }
}

#高亮查询
GET lhy/user/_search
{
  "query": {
      "match": {
        "name":"狂神"
      }
  },
  "highlight": {
    "fields": {
      "name":{}
    }
  }
}

  

集成SpringBoot

找官方文档!

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第72张图片

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第73张图片

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第74张图片

  1. 找到原生的依赖

    <dependency>
      <groupId>org.elasticsearch.clientgroupId>
      <artifactId>elasticsearch-rest-high-level-clientartifactId>
      <version>7.6.2version>
    dependency>
    
  2. 找对象

    【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第75张图片

  3. 分析这个类中的方法即可!

配置基本的项目

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

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第76张图片

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第77张图片

源码中提供对象!

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第78张图片

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

/**
* 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();
        }
    }
}

具体的Api测试!

  1. 创建索引
  2. 判断索引是否存在
  3. 删除索引
  4. 创建文档
  5. crud文档!
@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());
        }
    }
}

实战

新建jd boot的项目

之后我们设置端口和把 thymeleaf的缓存关掉,之后访问一下 index 查看

代码已开源 ,这里只展示核心功能

我们的思路就是暂时2不去使用数据库 用JSONP来拿到页面数据 存入ES

  • API添加数据到ES
  • 搜索关键词 ES展现出来,
  • 前端高亮

【搜索引擎:Elasticsearch】从0了解ES,整合springboot,京东搜索实战_第79张图片

爬虫

数据怎么来?从数据库获取,消息队列中获取,都可以成为数据源 爬虫!

需要使用爬虫来爬取数据

   public List parseJD(String keywords) throws IOException {
        //    https://search.jd.com/Search?keyword=java
        // 前提需要联网
        String url = "https://search.jd.com/Search?keyword=" + keywords + "&enc=utf-8";
        //解析网页(jsoup返回document就是js,浏览器的Document对象)
        Document document = Jsoup.parse(new URL(url), 30000);
        //所有我们再js中可以操作的,在这里都可以
        Element element = document.getElementById("J_goodsList");
        //System.out.println(element.html());
        //获取所有的li标签
        Elements li_elements = document.getElementsByTag("li");
        ArrayList goodsList = new ArrayList<>();
        for (Element el : li_elements) {
            if (el.attr("class").equalsIgnoreCase("gl-item")) {
                String img = el.getElementsByTag("img").eq(0).attr("data-lazy-img");
                String price = el.getElementsByClass("p-price").eq(0).text();
                String title = el.getElementsByClass("p-name").eq(0).text();
                content content = new content();
                content.setTitle(title);
                content.setImg(img);
                content.setPrice(price);
                goodsList.add(content);
            }
        }
        return goodsList;
    }

关键高亮

  • 确定条件
  • 查询方式
  • 执行
  • 解析高亮
  • 处理高亮
  • 返回结果
    //获取数据实现搜索高亮功能
    public List<Map<String, Object>> getContentHighContent(String keywords, int pageNo, int pageSize) throws IOException {
        if (pageNo < 1) {
            pageNo = 1;
        }
        //条件搜索
        SearchRequest searchRequest = new SearchRequest("jd_goods");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.from(pageNo);
        searchSourceBuilder.size(pageSize);
        //精确查询
        MatchBoolPrefixQueryBuilder queryBuilder = QueryBuilders.matchBoolPrefixQuery("title", keywords);
        searchSourceBuilder.query(queryBuilder);
        searchSourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
        //配置高亮
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.field("title");
        highlightBuilder.requireFieldMatch(false); //多个高亮关闭
        highlightBuilder.preTags("");
        highlightBuilder.postTags("");

        searchSourceBuilder.highlighter(highlightBuilder);
        //执行搜索
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = Client.search(searchRequest, RequestOptions.DEFAULT);
        ArrayList<Map<String, Object>> list = new ArrayList<>();
        for (SearchHit documentFields : searchResponse.getHits().getHits()) {
            //解析高亮的字段
            Map<String, HighlightField> highlightFields = documentFields.getHighlightFields();
            HighlightField title = highlightFields.get("title");
            Map<String, Object> sourceAsMap = documentFields.getSourceAsMap();
            if (title != null) {
                //取出全部的高亮title
                Text[] texts = title.fragments();
                String name = "";
                //拼接成新字段
                for (Text text : texts) {
                    name += text;
                }
                //如果需要就替换原来获取到的title
                sourceAsMap.put("title", name);
            }
            list.add(sourceAsMap);
        }
        return list;
    }

之后我们需要用前端

vue 去解析html

 <!--标题-->
<p class="productTitle">
 <a v-html="result.title"></a>
</p>

你可能感兴趣的