ElasticSearch（elasticsearch原理）

　　本篇文章为你整理了ElasticSearch（elasticsearch原理）的详细内容，包含有elasticsearch应用场景 elasticsearch原理 elasticsearch怎么读 elasticsearch教程 ElasticSearch，希望能帮助你了解 ElasticSearch。

　　是一个开放源代码的全文检索引擎工具包

　　不是一个完整的全文检索引擎，而是一个全文检索引擎的架构，提供了完整的查询引擎和索引引擎，部分文本分析引擎（英文与德文两种西方语言）

　　当前以及最近几年最受欢迎的免费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 下载

　　ElasticSearch下载地址：https://mirrors.huaweicloud.com/elasticsearch/7.6.1

　　下载完解压即可；

　　2.1.2 熟悉目录

bin 启动文件目录

　　config 配置文件目录

　　 1og4j2 日志配置文件

　　 jvm.options java 虚拟机相关的配置(默认启动占1g内存，内容不够需要自己调整)

　　 elasticsearch.ym1 elasticsearch 的配置文件! 默认9200端口!跨域!

　　相关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安装依赖与启动

cd elasticsearch-head

　　# 安装依赖

　　npm install

　　npm run start

　　或者 npm start （后面我一直使用的是这个）

　　http://localhost:9100/

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

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

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

　　2.2.3访问

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

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

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

# 开启跨域

　　http.cors.enabled: true

　　# 所有人访问

　　http.cors.allow-origin: "*"

　　再次连接，连接成功

　　如何理解上图：

　　
2.3安装 kibana

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

　　2.3.1 下载

　　kibana下载地址：https://mirrors.huaweicloud.com/kibana/7.6.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

　　
其中Elasticsearch是一个基于Lucene、分布式、通过Restful方式进行交互的近实时搜索平台框架。

　　像类似百度、谷歌这种大数据全文搜索引擎的场景都可以使用Elasticsearch作为底层支持框架，可见Elasticsearch提供的搜索能力确实强大,市面上很多时候我们简称Elasticsearch为es。

　　Logstash是ELK的中央数据流引擎,用于从不同目标(文件/数据存储/MQ )收集的不同格式数据,经过过滤后支持输出到不同目的地(文件/MQ/redis/elasticsearch/kafka等)。

　　Kibana可以将elasticsearch的数据通过友好的页面展示出来 ,提供实时分析的功能。

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

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

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

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

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

　　3.3 物理设计:

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

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

　　3.4 逻辑设计：

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

　　3.4.1 文档（”行“）

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

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

　　可以是层次型的，一个文档中包含自文档，复杂的逻辑实体就是这么来的!

　　灵活的结构，文档不依赖预先定义的模式，我们知道关系型数据库中，要提前定义字段才能使用，在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：最少切分

GET _analyze

　　 "analyzer": "ik_smart",

　　 "text": "全世界"

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

GET _analyze

　　 "analyzer": "ik_max_word",

　　 "text": "全世界"

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

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

GET _analyze

　　 "analyzer": "ik_max_word",

　　 "text": "超喜欢狂神说Java"

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

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

　　1.创建字典文件

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

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

　　配置自己的扩展字典：

　　4.重启，再次测试

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

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

　　5、关于索引的基本操作

　　5.1Rest风格说明

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

　　基本Rest命令说明：

　　
执行命令

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

　　5.2.2 字段数据类型

　　字符串类型

　　text、keyword

　　text：支持分词，全文检索,支持模糊、精确查询,不支持聚合,排序操作;text类型的最大支持的字符长度无限制,适合大字段存储；

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

　　GET test2 查看规则信息

　　5.3.4 查看默认信息

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

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

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

　　5.3.5 扩展：get _cat/

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

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覆盖原来的值（旧方法）

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

# 覆盖更新 修改后版本会增加

　　PUT /test3/_doc/1

　　 "name": "狂神说123",

　　 "age": 13,

　　 "birthday": "1997-01-05"

　　5.3.6.2 使用post的update跟新

　　需要注意doc

　　不会丢失字段

# post 更新 不会数据丢失

　　POST /test3/_doc/1/_update

　　 "doc":{

　　 "name": "法外狂徒张三"

　　5.3.7 删除索引

# 删除test1

　　DELETE test1

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

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

　　6、关于文档的基本操作

　　添加数据

# 关于文档的操作

　　# 基本操作

　　# 添加数据

　　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 条件查询(简单查询)

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

# 简单的搜索

　　GET kuangshen/user/1

　　# 简单的条件查询

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

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

　　6.2 复杂查询

GET kuangshen/user/_search

　　 "query": {

　　 "match": {

　　 "name": "狂神"

　　6.2.1 _score 字段过滤

GET kuangshen/user/_search

　　 "query": {

　　 "match": {

　　 "name": "狂神"

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

　　6.2.2 sort排序

　　desc 降序 asc 升序

# sort排序 desc 降序 asc 升序

　　GET kuangshen/user/_search

　　 "query": {

　　 "match": {

　　 "name": "狂神"

　　 "sort": [

　　 "age": {

　　 "order": "desc"

　　6.2.3 form size 分页查询

# 分页查询 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 匹配查询

# 多个条件使用空格隔开 (类似 in)

　　# 只要满足其中一个结果旧可以被查出来

　　# 这个时候可以通过分值基本的判断

　　GET kuangshen/user/_search

　　 "query": {

　　 "match": {

　　 "tags": "男技术"

　　6.2.4.2 must 等价 and

# 多条件查询

　　# 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

# should 表示or

　　GET kuangshen/user/_search

　　 "query": {

　　 "bool": {

　　 "should": [

　　 "match": {

　　 "name": "狂神说"

　　 "match": {

　　 "age": "23"

　　6.2.4.4 must_not 等价 not

# must_not 等价于not

　　GET kuangshen/user/_search

　　 "query": {

　　 "bool": {

　　 "must_not": [

　　 "match": {

　　 "name": "狂神说"

　　 "match": {

　　 "age": "23"

　　6.2.4.5 filter 对数据进行过滤

# 过滤器 filter 对数据进行过滤

　　GET kuangshen/user/_search

　　 "query": {

　　 "bool": {

　　 "must": [

　　 "match": {

　　 "name": "狂神说"

　　 "filter": {

　　 "range": {

　　 "age": {

　　 "gte": 10

　　# gt 大于

　　# gte 大于等于

　　# lt 小于

　　# lte 小于等于

　　6.2.4.6 匹配多个条件

# 匹配多个条件

　　# 多个条件使用空格隔开

　　# 只要满足其中一个结果就可以被查出

　　# 这个时候可以通过分值基本的判断

　　GET kuangshen/user/_search

　　 "query": {

　　 "match": {

　　 "tags": "女技术"

　　6.2.4.7 term 精确查询

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

　　关于分词：

　　trem:直接查询精确的

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

　　两个类型 text keywork

# 测试

　　# 创建索引

　　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" 模式

# keywork 模式 一个整体 不分词 没有被分析

　　GET _analyze

　　 "analyzer": "keyword",

　　 "text": "狂神说 Java name"

　　6.2.4.6.2 "analyzer": "standard"模式

# standard 模式 会进行分词

　　GET _analyze

　　 "analyzer": "standard",

　　 "text": "狂神说 Java name"

　　6.2.4.6.3 text 和 keywork 类型区别

# name的类型是text会被分词解析器解析，所以可以通过部分词搜索到

　　GET testdb/_search

　　 "query": {

　　 "term": {

　　 "name": {

　　 "value": "狂"

# keyword 类型的字段不会被分词解析，必须完全一样才可以搜索到

　　GET testdb/_search

　　 "query": {

　　 "term": {

　　 "desc": {

　　 "value": "狂神说 Java desc"

　　6.2.4.6.4 多个值匹配精确查询

# 精确查询多个值

　　# 插入数据

　　PUT testdb/_doc/3

　　 "t1": "22",

　　 "t2": "2020-4-6"

　　PUT testdb/_doc/4

　　 "t1": "33",

　　 "t2": "2020-4-7"

　　6.2.5 高亮查询 highlight

　　6.2.5.1 高亮查询

# 高亮查询

　　# highlight 只当的字段会被加上标签

　　GET kuangshen/user/_search

　　 "query": {

　　 "match": {

　　 "name": "狂神说"

　　 "highlight": {

　　 "fields": {

　　 "name":{}

　　6.2.5.2 自定义高亮标签

# 自定义搜索高亮条件 ,自定义标签

　　GET kuangshen/user/_search

　　 "query": {

　　 "match": {

　　 "name": "狂神说"

　　 "highlight": {

　　 "pre_tags": " p ",

　　 "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中原生依赖的位置

 dependency

　　 groupId org.elasticsearch.client /groupId

　　 artifactId elasticsearch-rest-high-level-client /artifactId

　　 version 7.6.2 /version

　　 /dependency

　　7.2.2 找对象

　　AIP中对象位置

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：

 properties

　　 java.version 1.8 /java.version

　　 !-- 自定义 es依赖，保证和本地版本一致 --

　　 elasticsearch.version 7.6.1 /elasticsearch.version

　　 /properties

　　7.3.2注入对象

　　自定义配置类

@Configuration

　　public class ElasticSearchClientConfig {

　　 @Bean

　　 public RestHighLevelClient restHighLevelClient(){

　　 RestHighLevelClient client = new RestHighLevelClient(

　　 RestClient.builder(

　　 new HttpHost("localhost", 9200, "http")));

　　 return client;

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

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

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 创建索引

//测试索引的创建 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 判断索引是否存在

//测试获取索引，只能判断其是否存在

　　@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 删除索引

//测试删除索引

　　@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 导入依赖

 !-- fastjson --

　　 dependency

　　 groupId com.alibaba /groupId

　　 artifactId fastjson /artifactId

　　 version 1.2.62 /version

　　 /dependency

　　7.4.4.2 创建实体类

@Data

　　@AllArgsConstructor

　　@NoArgsConstructor

　　@Component

　　public class User {

　　 private String name;

　　 private int age;

　　7.4.4.3 添加文档

//测试添加文档

　　@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 判断文档是否存在

//判断文档是否存在

　　@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 获得文档的信息

//获取文档信息

　　@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 更新文档信息

//更新文档的信息

　　@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 删除文档

//删除文档记录

　　@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 批量处理请求

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

　　@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 查询

// 查询

　　//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=%2F

　　提取码：qk8p

　　感谢这位老铁- 杀神TH

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

　　indexController.java

@Controller

　　public class IndexController {

　　 @GetMapping({"/","/index"})

　　 public String index(){

　　 return "index";

　　8.2 爬取数据

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

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

　　pojo:

@Data

　　@AllArgsConstructor

　　@NoArgsConstructor

　　@Component

　　public class Content {

　　 private String title;

　　 private String img;

　　 private String price;

　　工具类：

@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){

　　 //关于这种图片特别多的网。

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

相关文章阅读