ElasticSearch_ 字节宝

1、ElasticSearch简介

1.1 Lucene

Doug Cutting开发
是apache软件基金会4 jakarta项目组的一个子项目
是一个开放源代码的全文检索引擎工具包
不是一个完整的全文检索引擎，而是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎，部分文本分析引擎（英文与德文两种西方语言）
当前以及最近几年最受欢迎的免费Java信息检索程序库。

Lucene和ElasticSearch的关系：

ElasticSearch是基于Lucene 做了一下封装和增强

1.2 ElasticSearch 概述

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

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

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

ELK技术： elasticsearch logstash kibana

1.3 ES和Solr

1.3.1 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的复杂性,从而让全文搜索变得简单。

1.3.2 Solr简介

Solr是Apache下的一个顶级开源项目,采用Java开发,它是基于Lucene的全文搜索服务器。Solr提供了比Lucene更为丰富的查询语言,同时实现了可配置、可扩展，并对索引、搜索性能进行了优化
Solr可以独立运行,运行在letty. Tomcat等这些Selrvlet容器中 , 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请求,向搜索引擎服务器提交-定格式的文件,生成索引;也可以通过提出查找请求,并得到返回结果。

1.3.3 ElasticSearch与Solr比较

当单纯的对已有数据进行搜索时，Solr更快

2.当实时建立索引时，Solr会产生io阻塞，查询性能较差，ElasticSearch具有明显的优势

3.随着数据量的增加，Solr的搜索效率会变得更低，而ElasticSearch却没有明显的变化

4.转变我们的搜索基础设施后从Solr ElasticSearch，我们看见一个即时~ 50x提高搜索性能！

1.3.4 总结

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

2、ElasticSearch安装

JDK8，最低要求；

使用Java开发，必须保证ElasticSearch的版本与Java的核心jar包版本对应！（Java环境保证没错）

2.1 ElasticSearch

2.1.1 下载

下载完解压即可；

2.1.2 熟悉目录

代码语言：javascript复制

bin 启动文件目录
config 配置文件目录
    1og4j2 日志配置文件
    jvm.options java 虚拟机相关的配置(默认启动占1g内存，内容不够需要自己调整)
    elasticsearch.ym1 elasticsearch 的配置文件! 默认9200端口!跨域!
1ib 
    相关jar包
modules 功能模块目录
plugins 插件目录
    ik分词器

2.1.3 启动

1.点击：elasticsearch.bat

2.访问地址：127.0.0.1:9200

3.访问测试成功

2.2 安装elasticsearch-head可视化界面

elasticsearch-head

使用前提：需要安装node.js

2.2.1 下载

elasticsearch-head下载地址：https://github.com/mobz/elasticsearch-head/archive/master.zip

下载完解压即可；

2.2.2安装依赖与启动

代码语言：javascript复制

cd elasticsearch-head
# 安装依赖
npm install
# 启动
npm run start
# 访问
http://localhost:9100/

访问地址：http://loacalhost:9100

使用罗技鼠标插件的可能会占用9100端口

关闭LGHUBUpdateService服务即可；或者修改elasticsearch-head的端口，反正两个不用端口冲突就好；

2.2.3访问

存在跨域问题（只有当两个页面同源，才能交互）；

同源（端口，主机，协议三者都相同）;

开启跨域（在elasticsearch解压目录config下elasticsearch.yml中添加）

代码语言：javascript复制

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

再次连接，连接成功

如何理解上图：

如果你是初学者
- 索引可以看做 “数据库”
- 类型可以看做 “表”
- 文档可以看做 “库中的数据（表中的行）”
这个head，我们只是把它当做可视化数据展示工具，之后所有的查询都在kibana中进行
- 因为不支持json格式化，不方便

2.3安装 kibana

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

2.3.1 下载

下载后解压即可；

2.3.2 启动

点击kibana.bat;

访问：http://localhost:5601

访问成功

2.3.3 控制台

2.3.4kibana 汉化

编辑器打开kibana解压目录/config/kibana.yml，添加 i18n.locale: "zh-CN"

zh-CH.json文件

2.3.5 了解ELK

ELK是
- Elasticsearch、Logstash、 Kibana三大开源框架首字母大写简称
- 市面上也被成为Elastic Stack。
- 其中Elasticsearch是一个基于Lucene、分布式、通过Restful方式进行交互的近实时搜索平台框架。
- 像类似百度、谷歌这种大数据全文搜索引擎的场景都可以使用Elasticsearch作为底层支持框架，可见Elasticsearch提供的搜索能力确实强大,市面上很多时候我们简称Elasticsearch为es。
- Logstash是ELK的中央数据流引擎,用于从不同目标(文件/数据存储/MQ )收集的不同格式数据,经过过滤后支持输出到不同目的地(文件/MQ/redis/elasticsearch/kafka等)。
- Kibana可以将elasticsearch的数据通过友好的页面展示出来 ,提供实时分析的功能。
市面上很多开发只要提到ELK能够一致说出它是一个日志分析架构技术栈总称 ,但实际上ELK不仅仅适用于日志分析,它还可以支持其它任何数据分析和收集的场景,日志分析和收集只是更具有代表性。并非唯一性。

代码语言：javascript复制

收集清洗数据(Logstash) ==> 搜索、存储(ElasticSearch) ==> 展示(Kibana)

3、ElasticSearch核心概念

3.1 概述

索引
- 包含多个分片
字段类型（mapping）
文档（documents）
分片（Lucence索引，倒排索引）

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

3.2 关系行数据库和ElasticSearch客观对比

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

Relational DB	ElasticSearch
数据库（database）	索引（indices）
表（tables）	types <慢慢会被弃用!>
行（rows）	documents
字段（columns）	fields

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

3.3 物理设计:

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

一个人就是一个集群! ，即启动的ElasticSearch服务，默认就是一个集群，且默认集群名为elasticsearch；

3.4 逻辑设计：

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

3.4.1 文档（”行“）

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

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

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

3.4.2 类型（“表”）

类型是文档的逻辑容器，就像关系型数据库一样，表格是行的容器。类型中对于字段的定义称为映射，比如name映射为字符串类型。我们说文档是无模式的，它们不需要拥有映射中所定义的所有字段，比如新增一个字段，那么elasticsearch是怎么做的呢?

elasticsearch会自动的将新字段加入映射，但是这个字段的不确定它是什么类型，elasticsearch就开始猜，如果这个值是18，那么elasticsearch会认为它是整形。但是elasticsearch也可能猜不对，所以最安全的方式就是提前定义好所需要的映射，这点跟关系型数据库殊途同归了，先定义好字段，然后再使用，别整什么幺蛾子。

3.4.3 索引（“库”）

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

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

创建新索引

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

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

3.4.3.1 倒排索引（Lucene索引底层）

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

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

3.4.3.2 elasticsearch的索引和Lucene的索引对比

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

4、IK分词器(elasticsearch插件)

4.1 IK分词器：中文分词器

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

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

4.2 下载

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

下载后解压到ElasticSearch的plugins目录ik（自己添加一个名为ik的文件夹）文件夹下：

4.3 重启ElasticSearch

加载了IK分词器

4.4 elasticsearch-plugin list 命令查看插件

4.5 使用kibana测试

4.5.1 查看不同的分词效果

ik_smart：最少切分

代码语言：javascript复制

GET _analyze
{
  "analyzer": "ik_smart",
  "text": "全世界"
}

ik_max_word：最细粒度划分（穷尽词库的可能）

代码语言：javascript复制

GET _analyze
{
  "analyzer": "ik_max_word",
  "text": "全世界"
}

4.5.2 添加自定义的词添加到扩展字典中

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

代码语言：javascript复制

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

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

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

1.创建字典文件

2.添加字典内容：kuang.dic

3.将自己的字典文件配置到ik分词器的配置文件中：

配置自己的扩展字典：

4.重启，再次测试

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

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

5、关于索引的基本操作

5.1Rest风格说明

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

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

5.2 增删改查

5.2.1 创建索引

代码语言：javascript复制

PUT /索引名/~类型名~/文档id        #类型名后面弃用了
{
    请求体
}

代码语言：javascript复制

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

执行命令

完成了自动增加索引，数据也添加了，添加了文档（“行”）![image-20220725111741302]

5.2.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
等等…

5.2.3 指定字段的类型

创建规则

代码语言：javascript复制

# 创建规则
PUT /test2
{
  "mappings": {
    "properties": {
      "name": {
        "type": "text"
      },
      "age": {
        "type": "long"
      },
      "birthday": {
        "type": "date"
      }
    }
  }
}

GET test2 查看规则信息

5.3.4 查看默认信息

直接插入数据，不创建规则，自动匹配数据类型；

查看test索引的默认匹配数据类型：

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

5.3.5 扩展：get _cat/

通过get _cat/可以获取ElasticSearch的当前的很多信息！

代码语言：javascript复制

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.3.6 修改

5.3.6.1 使用put覆盖原来的值（旧方法）

注意：覆盖修改,会数据丢失，如果原来的数据有多个字段，但是新数据只有一个字段，则其他没有新数据的字段会没有数据；（原理先删除后增加）

代码语言：javascript复制

# 覆盖更新 修改后版本会增加
PUT /test3/_doc/1
{
  "name": "狂神说123",
  "age": 13,
  "birthday": "1997-01-05"
}

5.3.6.2 使用post的update跟新

需要注意doc
不会丢失字段

代码语言：javascript复制

# post 更新  不会数据丢失
POST /test3/_doc/1/_update
{
  "doc":{
    "name": "法外狂徒张三"
  }
}

5.3.7 删除索引

代码语言：javascript复制

# 删除test1
DELETE test1

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

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

6、关于文档的基本操作

添加数据

代码语言：javascript复制

# 关于文档的操作
# 基本操作
# 添加数据
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": "mpm,不知道怎么形容",
  "tags": ["靓女","旅游","唱歌"]
}

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

6.1 条件查询(简单查询)

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

代码语言：javascript复制

# 简单的搜索
GET kuangshen/user/1

# 简单的条件查询
GET kuangshen/user/_search?q=name:狂神说

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

6.2 复杂查询

代码语言：javascript复制

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

6.2.1 _score 字段过滤

代码语言：javascript复制

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

6.2.2 sort排序

desc 降序 asc 升序

代码语言：javascript复制

# sort排序 desc 降序 asc 升序
GET kuangshen/user/_search
{
  "query": {
    "match": {
      "name": "狂神"
    }
  },
 "sort": [
   {
     "age": {
       "order": "desc"
     }
   }
 ]
}

6.2.3 form size 分页查询

代码语言：javascript复制

# 分页查询 from:从第一个数据开始 size:返回多少条数据
GET kuangshen/user/_search
{
  "query": {
    "match": {
      "name": "狂神"
    }
  },
 "sort": [
   {
     "age": {
       "order": "desc"
     }
   }
 ],
 "from": 0,
 "size": 2
}
# 数据下标从0开始

6.2.4 布尔值查询

6.2.4.1 match 匹配查询

代码语言：javascript复制

# 多个条件使用空格隔开 (类似 in)
# 只要满足其中一个结果旧可以被查出来
# 这个时候可以通过分值基本的判断
GET kuangshen/user/_search
{
  "query": {
    "match": {
      "tags": "男 技术"
    }
  }
}

6.2.4.2 must 等价 and

代码语言：javascript复制

# 多条件查询
# must 表示and,所有的条件都要符合 类似where id  = 1 and name = xxx
GET kuangshen/user/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
          "name": "狂神说"
          }
          
        },
        {
          "match": {
            "age": "23"
          }
        }
      ]
    }
  }
}

6.2.4.3 should 等价or

代码语言：javascript复制

# should 表示or
GET kuangshen/user/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "match": {
          "name": "狂神说"
          }
          
        },
        {
          "match": {
            "age": "23"
          }
        }
      ]
    }
  }
}

6.2.4.4 must_not 等价 not

代码语言：javascript复制

# must_not   等价于not 
GET kuangshen/user/_search
{
  "query": {
    "bool": {
      "must_not": [
        {
          "match": {
          "name": "狂神说"
          }
          
        },
        {
          "match": {
            "age": "23"
          }
        }
      ]
    }
  }
}

6.2.4.5 filter 对数据进行过滤

代码语言：javascript复制

# 过滤器 filter 对数据进行过滤
GET kuangshen/user/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
          "name": "狂神说"
          }
          
        }
      ],
      "filter": {
        "range": {
          "age": {
            "gte": 10
          }
        }
      }
    }
  }
}
# gt 大于
# gte 大于等于
# lt 小于
# lte 小于等于

6.2.4.6 匹配多个条件

代码语言：javascript复制

# 匹配多个条件
# 多个条件使用空格隔开
# 只要满足其中一个结果就可以被查出
# 这个时候可以通过分值基本的判断
GET kuangshen/user/_search
{
  "query": {
    "match": {
      "tags": "女 技术"
    }
  }
}

6.2.4.7 term 精确查询

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

关于分词：

trem:直接查询精确的
match:会使用分词器解析！（先分析文档，然后通过分析的文档进行查询；）
两个类型 text keywork

代码语言：javascript复制

# 测试
# 创建索引
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 name2",
  "desc": "狂神说 Java desc2"
}

6.2.4.6.1 "analyzer": "keyword" 模式

代码语言：javascript复制

# keywork 模式 一个整体 不分词 没有被分析
GET _analyze
{
  "analyzer": "keyword",
  "text": "狂神说 Java name"
}

6.2.4.6.2 "analyzer": "standard"模式

代码语言：javascript复制

# standard 模式 会进行分词
GET _analyze
{
  "analyzer": "standard",
  "text": "狂神说 Java name"
}

6.2.4.6.3 text 和 keywork 类型区别

代码语言：javascript复制

# name的类型是text会被分词解析器解析，所以可以通过部分词搜索到
GET testdb/_search
{
  "query": {
    "term": {
      "name": {
        "value": "狂"
      }
    }
  }
}

代码语言：javascript复制

# keyword 类型的字段不会被分词解析，必须完全一样才可以搜索到
GET testdb/_search
{
  "query": {
    "term": {
      "desc": {
        "value": "狂神说 Java desc"
      }
    }
  }
}

6.2.4.6.4 多个值匹配精确查询

代码语言：javascript复制

# 精确查询多个值
# 插入数据
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": 3
          }
        }
      ]
    }
  }
}

6.2.5 高亮查询 highlight

6.2.5.1 高亮查询

代码语言：javascript复制

# 高亮查询
# highlight 只当的字段会被加上标签
GET kuangshen/user/_search
{
  "query": {
    "match": {
      "name": "狂神说"
    }
  },
  "highlight": {
    "fields": {
      "name":{}
    }
  }
}

6.2.5.2 自定义高亮标签

代码语言：javascript复制

# 自定义搜索高亮条件 ,自定义标签
GET kuangshen/user/_search
{
  "query": {
    "match": {
      "name": "狂神说"
    }
  },
  "highlight": {
    "pre_tags": "<p class='key' style='color:red'>", 
    "post_tags": "</p>", 
    "fields": {
      "name":{}
    }
  }
}

7、SpringBoot整合

7.1 官方API

Java REST Client->https://www.elastic.co/guide/en/elasticsearch/client/java-rest/7.6/index.html

7.2 基本配置

7.2.1 找到原生的依赖

API中原生依赖的位置

代码语言：javascript复制

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

7.2.2 找对象

AIP中对象位置

代码语言：javascript复制

RestHighLevelClient client = new RestHighLevelClient(
        RestClient.builder(
                new HttpHost("localhost", 9200, "http"),
                new HttpHost("localhost", 9201, "http")));

client.close();

7.2.3 分析这个类中的方法

配置基本的项目

注意几个配置

JDK版本:

Javac编译版本

JavaScript版本

7.3 搭建环境

7.3.1 依赖

7.3.1.1 确保elasticsearch的版本和我们本地版本一致

1 查看版本是否一致：

2 自定义我们需要的版本7.6.1：

代码语言：javascript复制

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

7.3.2注入对象

自定义配置类

代码语言：javascript复制

@Configuration
public class ElasticSearchClientConfig {

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

}

源码中提供的对象(可以直接拿来用)

虽然这里导入了3个类，静态内部类，但是核心类就只有一个：

代码语言：javascript复制

class RestClientConfigurations {
    RestClientConfigurations() {
    }

    @Configuration(
        proxyBeanMethods = false
    )
    static class RestClientFallbackConfiguration {
        RestClientFallbackConfiguration() {
        }

        @Bean
        @ConditionalOnMissingBean
        RestClient elasticsearchRestClient(RestClientBuilder builder) {
            return builder.build();
        }
    }

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

        //RestClient 普通客户端
        @Bean
        @ConditionalOnMissingBean
        RestClient elasticsearchRestClient(RestClientBuilder builder, ObjectProvider<RestHighLevelClient> restHighLevelClient) {
            RestHighLevelClient client = (RestHighLevelClient)restHighLevelClient.getIfUnique();
            return client != null ? client.getLowLevelClient() : builder.build();
        }
    }

    @Configuration(
        proxyBeanMethods = false
    )
    static class RestClientBuilderConfiguration {
        RestClientBuilderConfiguration() {
        }

        //RestClientBuilder
        @Bean
        @ConditionalOnMissingBean
        RestClientBuilder elasticsearchRestClientBuilder(RestClientProperties properties, ObjectProvider<RestClientBuilderCustomizer> builderCustomizers) {
            HttpHost[] hosts = (HttpHost[])properties.getUris().stream().map(HttpHost::create).toArray((x$0) -> {
                return new HttpHost[x$0];
            });
            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) -> {
                    return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
                });
            });
            builder.setRequestConfigCallback((requestConfigBuilder) -> {
                properties.getClass();
                map.from(properties::getConnectionTimeout).whenNonNull().asInt(Duration::toMillis).to(requestConfigBuilder::setConnectTimeout);
                properties.getClass();
                map.from(properties::getReadTimeout).whenNonNull().asInt(Duration::toMillis).to(requestConfigBuilder::setSocketTimeout);
                return requestConfigBuilder;
            });
            builderCustomizers.orderedStream().forEach((customizer) -> {
                customizer.customize(builder);
            });
            return builder;
        }
    }
}

7.4 测试API

7.4.1 创建索引

代码语言：javascript复制

//测试索引的创建 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);
}

7.4.2 判断索引是否存在

代码语言：javascript复制

//测试获取索引，只能判断其是否存在
@Test
void testExistIndex() throws IOException {
    GetIndexRequest request = new GetIndexRequest("kuang_index");
    boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
    System.out.println("kuang_index是否存在:" exists);
}

7.4.3 删除索引

代码语言：javascript复制

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

7.4.4 添加文档

7.4.4.1 导入依赖

代码语言：javascript复制

<!--   fastjson     -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.62</version>
</dependency>

7.4.4.2 创建实体类

代码语言：javascript复制

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

7.4.4.3 添加文档

代码语言：javascript复制

//测试添加文档
@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
    IndexRequest source = request.source(JSON.toJSON(user), XContentType.JSON);

    //客户端发请求,获取相应的结果
    IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);

    System.out.println(indexResponse.toString());
    //IndexResponse[index=kuang_index,type=_doc,id=1,version=1,result=created,seqNo=0,primaryTerm=1,shards={"total":2,"successful":1,"failed":0}]
    System.out.println(indexResponse.status()); //对应返回的状态 CREATED

}

7.4.5 判断文档是否存在

代码语言：javascript复制

//判断文档是否存在
@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("判断1号文档是否存在:"   exists);
    //判断1号文档是否存在:true
}

7.4.6 获得文档的信息

代码语言：javascript复制

//获取文档信息
@Test
void testGetDocument() throws IOException {
    GetRequest getRequest = new GetRequest("kuang_index", "1");
    GetResponse getResponse = client.get(getRequest, RequestOptions.DEFAULT);

    System.out.println(getResponse.getSourceAsString()); //打印文档内容
    //
}

7.4.7 更新文档信息

代码语言：javascript复制

//更新文档的信息
@Test
void testUpdateDocument() 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); //XContentType.JSON 传入的数据类型

    UpdateResponse updateResponse = client.update(updateRequest, RequestOptions.DEFAULT);

    System.out.println("文档是否跟新成功:" updateResponse.status());
}

7.4.8 删除文档

代码语言：javascript复制

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

7.4.9 批量处理请求

代码语言：javascript复制

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

    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("kuangshen4",3));
    userList.add(new User("kuangshen5",3));
    userList.add(new User("kuangshen6",3));

    //批处理请求
    for (int i = 0; i < userList.size(); i  ) {
         //批量更新和批量删除，就在这里修改对应的请求就可以了
        bulkRequest.add(
            new IndexRequest("kuang_index")
            .id("" (i 1)) //不设置id就会默认生成随机id
            .source(JSON.toJSONString(userList.get(i)),XContentType.JSON)
        );
    }

    BulkResponse bulkResponse = client.bulk(bulkRequest, RequestOptions.DEFAULT);

    System.out.println("添加处理请求是否失败：" bulkResponse.hasFailures()); //false表示成功，true表示失败
}

7.4.10 查询

代码语言：javascript复制

// 查询
//SearchRequest 搜索请i去
//searchSourceBuilder 条件构造器
//HighlightBuilder 构建高亮
//TermQueryBuilder 精确查询
//MatchAllQueryBuilder
// xxxQueryBuilder 对应我们之前的所有命令
@Test
void testSearch() throws IOException {
    SearchRequest searchRequest = new SearchRequest("kuang_index");
    //构建搜索条件
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

    //查询条件，我们可以使用QueryBuilders工具来实现
    //QueryBuilders.termQuery 精确查询
    //QuertBuilders.matchAllQuery() 匹配所有
    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.getHits()));
    //查询结果：{"fragment":true,"hits":[{"fields":{},"fragment":false,"highlightFields":{},"id":"1","matchedQueries":[],"primaryTerm":0,"rawSortValues":[],"score":1.540445,"seqNo":-2,"sortValues":[],"sourceAsMap":{"name":"kuangshen1","age":3},"sourceAsString":"{"age":3,"name":"kuangshen1"}","sourceRef":{"fragment":true},"type":"_doc","version":-1}],"maxScore":1.540445,"totalHits":{"relation":"EQUAL_TO","value":1}}
    System.out.println("===================");
    for (SearchHit documentFields : searchResponse.getHits().getHits()) {
        System.out.println(documentFields.getSourceAsMap());
    }
    //{name=kuangshen1, age=3}
}

8、京东搜索

8.1 项目搭建

素材连接：https://pan.baidu.com/s/1M5uWdYsCZyzIAOcgcRkA_A#list/path=/

提取码：qk8p

感谢这位老铁->杀神TH

导入素材启动项目，访问页面

indexController.java

代码语言：javascript复制

@Controller
public class IndexController {
    @GetMapping({"/","/index"})
    public String index(){
        return "index";
    }
}

8.2 爬取数据

数据问题？数据库获取，消息队列，消息队列中获取，都可以成为数据源，爬虫！

爬虫数据：（获取请求返回的页面信息，筛选出我们想要的数据就可以了！）

pojo:

代码语言：javascript复制

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

}

工具类：

代码语言：javascript复制

@Component
public class HtmlParseUtil {
    public static void main(String[] args) throws Exception {
        new HtmlParseUtil().parseJD("java").forEach(System.out::println);

    }

    public ArrayList<Content> parseJD(String keyword) throws Exception{
        //获取请求https://search.jd.com/Search?keyword=java
        //前提，需要联网，ajax 不能获取到
        String url = "https://search.jd.com/Search?keyword=" keyword;
        //解析网页(Jsoup返回Document就是浏览器Document对象)
        Document document = Jsoup.parse(new URL(url), 30000);
        //所有在js中可以使用的方法，这里都能使用
        Element element = document.getElementById("J_goodsList");
//        System.out.println(element.html());
        //获取所有的li元素
        Elements elements = element.getElementsByTag("li");

        ArrayList<Content> goodsList = new ArrayList<>();

        //获取元素中的内容，这里el，就是每个li标签
        for(Element el : elements){
            //关于这种图片特别多的网站，多有的图片都是延迟加载的！
            //source-data-lazy-img
//            String img = el.getElementsByTag("img").eq(0).attr("src");
            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();

//            System.out.println("=====================================");
//            System.out.println(img);
//            System.out.println(price);
//            System.out.println(title);
            Content content = new Content();
            content.setTitle(title);
            content.setImg(img);
            content.setPrice(price);
            goodsList.add(content);

        }

        return goodsList;
    }

}

8.3 业务编写

8.3.1 业务编写

ContentService

代码语言：javascript复制

//业务编写
@Service
public class ContentService {

    @Autowired
    private RestHighLevelClient restHighLevelClient;

    //1.解析数据放入es索引
    public Boolean parseContent(String keywords) throws Exception {
        ArrayList<Content> contents = new HtmlParseUtil().parseJD(keywords);
        //把查询到的数据放入es中
        BulkRequest bulkRequest = new BulkRequest();
        bulkRequest.timeout("2m");

        for (int i = 0; i < contents.size(); i  ) {
            System.out.println(JSON.toJSONString(contents.get(i)));
            bulkRequest.add(
                    new IndexRequest("jd_goods")
//                    .id("" (i 1))
                    .source(JSON.toJSONString(contents.get(i)), XContentType.JSON));
        }

        BulkResponse bulkResponse = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);

        return  !bulkResponse.hasFailures();
    }

    //2.获取这些数据实现搜索功能
    public List<Map<String,Object>> highlightSearch(String keyword,int pageNo,int pageSize) throws IOException {
        if(pageNo <= 1){
            pageNo = 1;
        }

        //条件搜索
        SearchRequest searchRequest = new SearchRequest("jd_goods");
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        //分页
        sourceBuilder.from(pageNo);
        sourceBuilder.size(pageSize);

        //精准匹配
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("title", keyword);
        sourceBuilder.query(termQueryBuilder);
        sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));

        //高亮
        HighlightBuilder highlightBuilder = new HighlightBuilder();
        highlightBuilder.field("title"); //高亮的字段
        highlightBuilder.requireFieldMatch(false); //多个高亮显示
        highlightBuilder.preTags("<span style='color:red'>");
        highlightBuilder.postTags("</span>");
        sourceBuilder.highlighter(highlightBuilder);

        //执行搜索
        searchRequest.source(sourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        //解析结果
        ArrayList<Map<String,Object>> list = new ArrayList<>();
        for (SearchHit hit : searchResponse.getHits().getHits()) {

            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            HighlightField title = highlightFields.get("title");
             Map<String,Object> sourceAsMap = hit.getSourceAsMap(); //原来的结果

            //解析高亮的字段
            if(title != null){
                Text[] fragments = title.fragments();
                String new_title = "";
                for (Text text : fragments) {
                    new_title  = text;
                }
                sourceAsMap.put("title",new_title);//高亮字段替换原来的内容即可
            }

            list.add(sourceAsMap);
        }

        return list;
    }

}

8.3.2 控制层

ContentController

代码语言：javascript复制

//请求编写
@Controller
public class ContentController {

    @Autowired
    private ContentService contentService;

    @ResponseBody
    @GetMapping("/parse/{keyword}")
   public Boolean parse(@PathVariable("keyword") String keyword) throws Exception {
       return contentService.parseContent(keyword);
   }

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

}

8.4 Index.html

代码语言：javascript复制

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">

<head>
    <meta charset="utf-8"/>
    <title>狂神说Java-ES仿京东实战</title>
    <link rel="stylesheet" th:href="@{/css/style.css}"/>
    <script th:src="@{/js/jquery.min.js}"></script>
<!--    <script src="../static/js/jquery.min.js"></script>-->
    <script th:src="@{/js/jquery.min.js}"></script>
</head>

<body class="pg">
<div class="page" id="app">
    <div id="mallPage" class=" mallist tmall- page-not-market ">

        <!-- 头部搜索 -->
        <div id="header" class=" header-list-app">
            <div class="headerLayout">
                <div class="headerCon ">
                    <!-- Logo-->
                    <h1 id="mallLogo">
                        <img th:src="@{/images/jdlogo.png}" alt="">
                    </h1>

                    <div class="header-extra">

                        <!--搜索-->
                        <div id="mallSearch" class="mall-search">
                            <form name="searchTop" class="mallSearch-form clearfix">
                                <fieldset>
                                    <legend>天猫搜索</legend>
                                    <div class="mallSearch-input clearfix">
                                        <div class="s-combobox" id="s-combobox-685">
                                            <div class="s-combobox-input-wrap">
                                                <input v-model="keyword" type="text" autocomplete="off" value="dd" id="mq"
                                                       class="s-combobox-input" aria-haspopup="true">
                                            </div>
                                        </div>
                                        <button type="submit" @click.prevent="searchKey" id="searchbtn">搜索</button>
                                    </div>
                                </fieldset>
                            </form>
                            <ul class="relKeyTop">
                                <li><a>狂神说Java</a></li>
                                <li><a>狂神说前端</a></li>
                                <li><a>狂神说Linux</a></li>
                                <li><a>狂神说大数据</a></li>
                                <li><a>狂神聊理财</a></li>
                            </ul>
                        </div>
                    </div>
                </div>
            </div>
        </div>

        <!-- 商品详情页面 -->
        <div id="content">
            <div class="main">
                <!-- 品牌分类 -->
                <form class="navAttrsForm">
                    <div class="attrs j_NavAttrs" style="display:block">
                        <div class="brandAttr j_nav_brand">
                            <div class="j_Brand attr">
                                <div class="attrKey">
                                    品牌
                                </div>
                                <div class="attrValues">
                                    <ul class="av-collapse row-2">
                                        <li><a href="#"> 狂神说 </a></li>
                                        <li><a href="#"> Java </a></li>
                                    </ul>
                                </div>
                            </div>
                        </div>
                    </div>
                </form>

                <!-- 排序规则 -->
                <div class="filter clearfix">
                    <a class="fSort fSort-cur">综合<i class="f-ico-arrow-d"></i></a>
                    <a class="fSort">人气<i class="f-ico-arrow-d"></i></a>
                    <a class="fSort">新品<i class="f-ico-arrow-d"></i></a>
                    <a class="fSort">销量<i class="f-ico-arrow-d"></i></a>
                    <a class="fSort">价格<i class="f-ico-triangle-mt"></i><i class="f-ico-triangle-mb"></i></a>
                </div>

                <!-- 商品详情 -->
                <div class="view grid-nosku">

                    <div class="product" v-for="result in results">
                        <div class="product-iWrap">
                            <!--商品封面-->
                            <div class="productImg-wrap">
                                <a class="productImg">
                                    <img :src="result.img">
                                </a>
                            </div>
                            <!--价格-->
                            <p class="productPrice">
                                <em>{{result.price}}</em>
                            </p>
                            <!--标题-->
                            <p class="productTitle">
                                <a v-html="result.title"> </a>
                            </p>
                            <!-- 店铺名 -->
                            <div class="productShop">
                                <span>店铺： 狂神说Java </span>
                            </div>
                            <!-- 成交信息 -->
                            <p class="productStatus">
                                <span>月成交<em>999笔</em></span>
                                <span>评价 <a>3</a></span>
                            </p>
                        </div>
                    </div>
                </div>
            </div>
        </div>
    </div>
</div>
<script th:src="@{/js/vue.min.js}"></script>
<script th:src="@{/js/axios.min.js}"></script>
<script>
    new Vue({
        el:"#app",
        data:{
            "keyword": '', // 搜索的关键字
            "results":[] // 后端返回的结果
        },
        methods:{
            searchKey(){
                var keyword = this.keyword;
                console.log(keyword);
                //对接
                axios.get('search/' keyword "/1/5").then(response=>{
                    console.log(response);
                    this.results = response.data; //
                })
            }
        }
    });
</script>

</body>
</html>

8.5 测试结果

笔记视频来源->B站狂神说Java的ElasticSearch课程

笔记部分参考-> ElasticSearch7.6入门学习笔记

ElasticsearchService 搜索引擎 lucene/solr 大数据数据分析

0 人点赞

ElasticSearch

1、ElasticSearch简介

1.1 Lucene

1.2 ElasticSearch 概述

1.3 ES和Solr

1.3.1 ElasticSearch简介

1.3.2 Solr简介

1.3.3 ElasticSearch与Solr比较

1.3.4 总结

2、ElasticSearch安装

2.1 ElasticSearch

2.1.1 下载

2.1.2 熟悉目录

2.1.3 启动

2.2 安装elasticsearch-head可视化界面

2.2.1 下载

2.2.2安装依赖与启动

2.2.3访问

2.3安装 kibana

2.3.1 下载

2.3.2 启动

2.3.3 控制台

2.3.4kibana 汉化

2.3.5 了解ELK

3、ElasticSearch核心概念

3.1 概述

3.2 关系行数据库和ElasticSearch客观对比

3.3 物理设计:

3.4 逻辑设计：

3.4.1 文档（”行“）

3.4.2 类型（“表”）

3.4.3 索引（“库”）

3.4.3.1 倒排索引（Lucene索引底层）

3.4.3.2 elasticsearch的索引和Lucene的索引对比

4、IK分词器(elasticsearch插件)

4.1 IK分词器：中文分词器

4.2 下载

4.3 重启ElasticSearch

4.4 elasticsearch-plugin list 命令 查看插件

4.5 使用kibana测试

4.5.1 查看不同的分词效果

4.5.2 添加自定义的词添加到扩展字典中

1.创建字典文件

2.添加字典内容：kuang.dic

3.将自己的字典文件配置到ik分词器的配置文件中：

4.重启，再次测试

5、关于索引的基本操作

5.1Rest风格说明

5.2 增删改查

5.2.1 创建索引

5.2.2 字段数据类型

5.2.3 指定字段的类型

5.3.4 查看默认信息

5.3.5 扩展：get _cat/

5.3.6 修改

5.3.6.1 使用put覆盖原来的值 （旧方法）

5.3.6.2 使用post的update跟新

5.3.7 删除索引

6、关于文档的基本操作

6.1 条件查询(简单查询)

6.2 复杂查询

6.2.1 _score 字段过滤

6.2.2 sort排序

6.2.3 form size 分页查询

6.2.4 布尔值查询

6.2.4.1 match 匹配查询

6.2.4.2 must 等价 and

6.2.4.3 should 等价or

6.2.4.4 must_not 等价 not

6.2.4.5 filter 对数据进行过滤

6.2.4.6 匹配多个条件

6.2.4.7 term 精确查询

6.2.4.6.1 "analyzer": "keyword" 模式

6.2.4.6.2 "analyzer": "standard"模式

6.2.4.6.3 text 和 keywork 类型区别

6.2.4.6.4 多个值匹配精确查询

6.2.5 高亮查询 highlight

6.2.5.1 高亮查询

6.2.5.2 自定义高亮标签

7、SpringBoot整合

4.4 elasticsearch-plugin list 命令查看插件

5.3.6.1 使用put覆盖原来的值（旧方法）