搜索引擎（Elastic Search）

ElasticSearch

版本：6.x，7.x的区别十分大

ElasticSearch：搜索

一个人：Doug Cutting

Lucene

大数据两个问题：存储+计算

Hadoop MapReduce HBase

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

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

Lucene和ElasticSearch关系：

ElasticSearch是基于Lucene做了一些封装和增强（上手十分简单）

培养学习兴趣

ElasticSearch概述

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

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

谁在使用

维基百科，类似百度百科，全文检索，高亮，搜索推荐
The Guardian（国外新闻网站），类似搜狐新闻，用户行为日志+社交网络数据，数据分析
Stack Overflow（国外的程序异常讨论论坛），IT问题，程序的报错，提交上去，有人会跟你讨论和回答
Github（开源代码管理），搜索上千亿行代码
电商网站，检索商品
日志数据分析，logstash采集日志，ES进行复杂的数据分析，ELK技术，elasticSearch+logstash+kibana
商品价格监控网站，用户设定某商品的价格阈值，当低于该阈值的时候，发送通知消息给用户，比如说订阅牙膏的监控，如果高露洁牙膏的家庭套装低于50块钱，就通知我，我就去买
BI系统，商业只能，Business Intelligence
国内：站内搜索（电商，招聘，门户，等），IT系统搜索（OA,CRM,ERP,等等），数据分析（ES热门的一个使用场景）

Solr和ES的对比及选型

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

特点：Solr是一个高性能，采用Java开发，基于Lucene的全文搜索服务器。同时对其进行了扩展，提供了比Lucene更为丰富的查询语言，同时实现了可配置、可扩展并对查询性能进行了优化，并且提供了一个完善的功能管理界面，是一款非常优秀的全文搜索引擎。

工作方式：

文档通过Http利用XML 加到一个搜索集合中。查询该集合也是通过http收到一个XML/JSON响应来实现。它的主要特性包括：高效、灵活的缓存功能，垂直搜索功能，高亮显示搜索结果，通过索引复制来提高可用性，提供一套强大Data Schema来定义字段，类型和设置文本分析，提供基于Web的管理界面等。

Elasticsearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java语言开发的，并作为Apache许可条款下的开放源码发布，是一种流行的企业级搜索引擎。Elasticsearch用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。官方客户端在Java、.NET（C#）、PHP、Python、Apache Groovy、Ruby和许多其他语言中都是可用的。根据DB-Engines的排名显示，Elasticsearch是最受欢迎的企业搜索引擎，其次是Apache Solr，也是基于Lucene。

Elasticsearch 是一个分布式、高扩展、高实时的搜索与数据分析引擎。它能很方便的使大量数据具有搜索、分析和探索的能力。充分利用Elasticsearch的水平伸缩性，能使数据在生产环境变得更有价值。Elasticsearch 的实现原理主要分为以下几个步骤，首先用户将数据提交到Elasticsearch 数据库中，再通过分词控制器去将对应的语句分词，将其权重和分词结果一并存入数据，当用户搜索数据时候，再根据权重将结果排名，打分，再将返回结果呈现给用户。

Elasticsearch是与名为Logstash的数据收集和日志解析引擎以及名为Kibana的分析和可视化平台一起开发的。这三个产品被设计成一个集成解决方案，称为“Elastic Stack”（以前称为“ELK stack”）。

Elasticsearch可以用于搜索各种文档。它提供可扩展的搜索，具有接近实时的搜索，并支持多租户。”Elasticsearch是分布式的，这意味着索引可以被分成分片，每个分片可以有0个或多个副本。每个节点托管一个或多个分片，并充当协调器将操作委托给正确的分片。再平衡和路由是自动完成的。“相关数据通常存储在同一个索引中，该索引由一个或多个主分片和零个或多个复制分片组成。一旦创建了索引，就不能更改主分片的数量。

Elasticsearch使用Lucene，并试图通过JSON和Java API提供其所有特性。它支持facetting和percolating，如果新文档与注册查询匹配，这对于通知非常有用。另一个特性称为“网关”，处理索引的长期持久性；例如，在服务器崩溃的情况下，可以从网关恢复索引。Elasticsearch支持实时GET请求，适合作为NoSQL数据存储，但缺少分布式事务。

ElasticSearch vs Solr总结

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

ElasticSearch安装及head插件安装

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

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

下载：

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

下载地址：https://www.elastic.co/cn/downloads/elasticsearch

window安装

解压就可以使用
熟悉目录

bin   启动文件
config  配置文件
	log4j2 日志配置文件
	jvm.options  java虚拟机相关的配置
	elasticsearch.yml   elasticsearch配置文件   包括默认端口：9200  跨域
lib  相关jar包
log  日志
modules 功能模块
plugins  插件    ik

启动:双击bin目录下elasticsearch.bat文件，访问http://127.0.0.1:9200/

{
  "name" : "SKY-20180930LIV",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "reLP3eF4QQysmLT1Yw32Xg",
  "version" : {
    "number" : "7.10.0",
    "build_flavor" : "default",
    "build_type" : "zip",
    "build_hash" : "51e9d6f22758d0374a0f3f5c6e8f3a7997850f96",
    "build_date" : "2020-11-09T21:30:33.964949Z",
    "build_snapshot" : false,
    "lucene_version" : "8.7.0",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}

安装可视化界面 es head 的插件

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

Running with built in server

git clone git://github.com/mobz/elasticsearch-head.git
cd elasticsearch-head
npm install
npm run start
open http://localhost:9100/

可以采用cnpm 命令

解决跨域问题

配置es，在elasticsearch.yml 下新增

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

重启elasticsearch
访问http://localhost:9100/ 连接http://localhost:9200/ 成功

初学，就把es当作一个数据库，（可以建立索引（库），文档（库中的数据））

这个head我们就把它当作数据展示工具，我们后面所有的擦汗寻，Kibana

Kibana的安装

了解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不仅仅适用于日志分析，它还可以支持其他任何数据分析和收集的场景，日志分析和收集只是更具有代表性。并非唯一性

安装Kibana

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

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

Kibana版本要和Es一致

下载解压

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

汉化：config/kibana.yml 修改配置最后一行

i18n.locale: "zh-CN"

启动bin目录下 kibana.bat 访问：http://localhost:5601/

访问网页 home 左侧栏 Dev Tools 之后所有的操作都在这里进行编写

ES核心概念理解

概述

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

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

ElasticSearch是面向文档，关系型数据库和elasticsearch客观的对比

Relationl DB	ElasticSearch
数据库（database）	索引（indices）
表（tables）	types
行（rows）	documents
字段（columns）	fields

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

物理设计

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

一个人就是一个集群，默认的集群名称就是elasticsearch

逻辑设计

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

文档

文档

就是我们的一条条的记录

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

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

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

类型

类型

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

索引

索引

就是数据库!

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

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

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

在这里插入图片描述

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

倒排索引

倒排索引

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

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

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

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

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

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

两个文档都匹配,但是第一个文档比第二个匹配程度更高。如果没有别的条件,现在,这两个包含关键字的文档都将返回。
再来看一个示例,比如我们通过博客标签来搜索博客文章。那么倒排索引列表就是这样的一个结构:

博客文章(原始数据)	博客文章(原始数据)	索引列表(倒排索引)	索引列表(倒排索引)
博客文章ID	标签	标签	博客文章ID
1	python	python	1，2，3
2	python	linux	3，4
3	linux，python
4	linux

如果要搜索含有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为最细粒度划分!一会我们测试!

什么是IK分词器：

把一句话分词
如果使用中文：推荐IK分词器
两个分词算法：ik_smart（最少切分），ik_max_word（最细粒度划分）

下载https://github.com/medcl/elasticsearch-analysis-ik

下载完毕之后，放入到我们的elasticsearch 插件即可D:\envoronment\elasticsearch-7.10.0\plugins\ik

重启观察ES 闪退记得把压缩包从plugins目录里移除， plugins存在解析不了的文件会闪退

elasticsearch-plugin list 命令可以查看加载了哪些插件

启动使用Kibana测试

访问http://localhost:5601/ 开发工具->控制台

【ik_smart】测试：

GET _analyze
{
  "analyzer": "ik_smart",
  "text": "我是社会主义接班人"
}

//输出
{
  "tokens" : [
    {
      "token" : "我",
      "start_offset" : 0,
      "end_offset" : 1,
      "type" : "CN_CHAR",
      "position" : 0
    },
    {
      "token" : "是",
      "start_offset" : 1,
      "end_offset" : 2,
      "type" : "CN_CHAR",
      "position" : 1
    },
    {
      "token" : "社会主义",
      "start_offset" : 2,
      "end_offset" : 6,
      "type" : "CN_WORD",
      "position" : 2
    },
    {
      "token" : "接班人",
      "start_offset" : 6,
      "end_offset" : 9,
      "type" : "CN_WORD",
      "position" : 3
    }
  ]
}

【ik_max_word】测试：

GET _analyze
{
  "analyzer": "ik_max_word",
  "text": "我是社会主义接班人"
}
//输出
{
  "tokens" : [
    {
      "token" : "我",
      "start_offset" : 0,
      "end_offset" : 1,
      "type" : "CN_CHAR",
      "position" : 0
    },
    {
      "token" : "是",
      "start_offset" : 1,
      "end_offset" : 2,
      "type" : "CN_CHAR",
      "position" : 1
    },
    {
      "token" : "社会主义",
      "start_offset" : 2,
      "end_offset" : 6,
      "type" : "CN_WORD",
      "position" : 2
    },
    {
      "token" : "社会",
      "start_offset" : 2,
      "end_offset" : 4,
      "type" : "CN_WORD",
      "position" : 3
    },
    {
      "token" : "主义",
      "start_offset" : 4,
      "end_offset" : 6,
      "type" : "CN_WORD",
      "position" : 4
    },
    {
      "token" : "接班人",
      "start_offset" : 6,
      "end_offset" : 9,
      "type" : "CN_WORD",
      "position" : 5
    },
    {
      "token" : "接班",
      "start_offset" : 6,
      "end_offset" : 8,
      "type" : "CN_WORD",
      "position" : 6
    },
    {
      "token" : "人",
      "start_offset" : 8,
      "end_offset" : 9,
      "type" : "CN_CHAR",
      "position" : 7
    }
  ]
}

ik分词器增加自己的配置

IKAnalyzer.cfg.xml 这是ik的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
	<comment>IK Analyzer 扩展配置</comment>
	<!--用户可以在这里配置自己的扩展字典 -->
	<entry key="ext_dict"></entry>
	 <!--用户可以在这里配置自己的扩展停止词字典-->
	<entry key="ext_stopwords"></entry>
	<!--用户可以在这里配置远程扩展字典 -->
	<!-- <entry key="remote_ext_dict">words_location</entry> -->
	<!--用户可以在这里配置远程扩展停止词字典-->
	<!-- <entry key="remote_ext_stopwords">words_location</entry> -->
</properties>

同级目录下编写ming.dic文件

小小明

配置文件加上ming.dic

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
	<comment>IK Analyzer 扩展配置</comment>
	<!--用户可以在这里配置自己的扩展字典 -->
	<entry key="ext_dict">ming.dic</entry>
	 <!--用户可以在这里配置自己的扩展停止词字典-->
	<entry key="ext_stopwords"></entry>
	<!--用户可以在这里配置远程扩展字典 -->
	<!-- <entry key="remote_ext_dict">words_location</entry> -->
	<!--用户可以在这里配置远程扩展停止词字典-->
	<!-- <entry key="remote_ext_stopwords">words_location</entry> -->
</properties>

重启ES

IK-smart测试

GET _analyze
{
  "analyzer": "ik_smart",
  "text": "我是小小明的Java"
}


//结果
{
  "tokens" : [
    {
      "token" : "我",
      "start_offset" : 0,
      "end_offset" : 1,
      "type" : "CN_CHAR",
      "position" : 0
    },
    {
      "token" : "是",
      "start_offset" : 1,
      "end_offset" : 2,
      "type" : "CN_CHAR",
      "position" : 1
    },
    {
      "token" : "小小明",
      "start_offset" : 2,
      "end_offset" : 5,
      "type" : "CN_WORD",
      "position" : 2
    },
    {
      "token" : "的",
      "start_offset" : 5,
      "end_offset" : 6,
      "type" : "CN_CHAR",
      "position" : 3
    },
    {
      "token" : "java",
      "start_offset" : 6,
      "end_offset" : 10,
      "type" : "ENGLISH",
      "position" : 4
    }
  ]
}

命令模式的使用

Rest风格说明

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

method	url地址	描述
PUT	localhost:9200/索引名称/类型名称/文档id	创建文档(指定文档id)
POST	localhost:9200/索引名称/类型名称	创建文档（随机文档id）
POST	localhost:9200/索引名称/类型名称/文档id/_update	修改文档
DELETE	localhost:9200/索引名称/类型名称/文档id	删除文档
GET	localhost:9200/索引名称/类型名称/文档id	通过文档id查询文档
POST	localhost:9200/索引名称/类型名称/_search	查询所有的数据

基础测试

1.创建一个索引

打开elasticsearch-head-master cnpm run start 访问http://localhost:9100

PUT /索引名/类型名(高版本都不写了，都是_doc)/文档id

{

请求体

}

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


输出
#! Deprecation: [types removal] Specifying types in document index requests is deprecated, use the typeless endpoints instead (/{index}/_doc/{id}, /{index}/_doc, or /{index}/_create/{id}).
{
  "_index" : "test1",
  "_type" : "type1",
  "_id" : "1",
  "_version" : 1,
  "result" : "created",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 0,
  "_primary_term" : 1
}

elasticsearch-head 查看数据浏览查询

6 个分片中用的 6 个. 1 命中. 耗时 0.003 秒

_index	_type	_id	▲_score	name	age
test1	type1	1	1	小明	3

索引
.apm-agent-configuration
.apm-custom-link
.kibana-event-log-7.10.0-000001
.kibana_1
.kibana_task_manager_1
ilm-history-3-000001
test1
类型
_doc
type1

name 这个字段可以指定类型

类型有

字符串类型

text ， keyword
数值类型

long， integer， short， byte ， double ， float ， half float ， scale float
日期类型

date
布尔值类型

boolean
二进制类型

binary
等。。

指定字段的类型

创建数据库，指定类型

PUT

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

输出
{
  "acknowledged" : true,
  "shards_acknowledged" : true,
  "index" : "test2"
}


elasticsearch-head   查看test2

GET获取信息

GET /test2

输出
{
  "test2" : {
    "aliases" : { },
    "mappings" : {
      "properties" : {
        "age" : {
          "type" : "long"
        },
        "birthday" : {
          "type" : "date"
        },
        "name" : {
          "type" : "text"
        }
      }
    },
    "settings" : {
      "index" : {
        "routing" : {
          "allocation" : {
            "include" : {
              "_tier_preference" : "data_content"
            }
          }
        },
        "number_of_shards" : "1",
        "provided_name" : "test2",
        "creation_date" : "1605841606533",
        "number_of_replicas" : "1",
        "uuid" : "J9mx_MqvQXuwOHzruNOZJA",
        "version" : {
          "created" : "7100099"
        }
      }
    }
  }
}

查看默认信息

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

PUT /test3/_doc/1
{
  "name": "小明",
  "age": 13,
  "birth": "1997-01-05"
}

输出
{
  "_index" : "test3",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 1,
  "result" : "created",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 0,
  "_primary_term" : 1
}



GET tests3


输出
{
  "test3" : {
    "aliases" : { },
    "mappings" : {
      "properties" : {
        "age" : {
          "type" : "long"
        },
        "birth" : {
          "type" : "date"
        },
        "name" : {
          "type" : "text",
          "fields" : {
            "keyword" : {
              "type" : "keyword",
              "ignore_above" : 256
            }
          }
        }
      }
    },
    "settings" : {
      "index" : {
        "routing" : {
          "allocation" : {
            "include" : {
              "_tier_preference" : "data_content"
            }
          }
        },
        "number_of_shards" : "1",
        "provided_name" : "test3",
        "creation_date" : "1605848624347",
        "number_of_replicas" : "1",
        "uuid" : "j5AmSRptSyedCvv_1F8LoQ",
        "version" : {
          "created" : "7100099"
        }
      }
    }
  }
}

cat命令

GET _cat/health

输出
1605848900 05:08:20 elasticsearch yellow 1 1 9 9 0 0 3 0 - 75.0%


GET _cat/indices?v

输出
health status index                           uuid                   pri rep docs.count docs.deleted store.size pri.store.size
yellow open   test2                           J9mx_MqvQXuwOHzruNOZJA   1   1          0            0       208b           208b
yellow open   test3                           j5AmSRptSyedCvv_1F8LoQ   1   1          1            0      4.3kb          4.3kb
green  open   .apm-custom-link                UgGddpBHRPiPeccPf7M8yQ   1   0          0            0       208b           208b
green  open   .kibana_task_manager_1          lXoM-IAcRQiaiCp8z86lQg   1   0          5          419    225.6kb        225.6kb
green  open   .apm-agent-configuration        6yyXyW4RTKOO_Ezr7zRQ_Q   1   0          0            0       208b           208b
green  open   .kibana-event-log-7.10.0-000001 RMIHiaq1SD6jhHwItvuHFQ   1   0          4            0     21.8kb         21.8kb
green  open   .kibana_1                       wVe3TfboS9e8IMBoduWFGQ   1   0         28            4     10.4mb         10.4mb
yellow open   test1                           20xDDDFYSO-zjZ_3u0oTPg   1   1          1            0        4kb            4kb

修改

put 。会覆盖，没有填写的字段会重置为空

PUT /test3/_doc/1
{
  "name": "小明123",
  "age": 13,
  "birth": "1997-01-05"
}

输出  版本号增加，状态updated
{
  "_index" : "test3",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 2,
  "result" : "updated",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 1,
  "_primary_term" : 1
}

post

update方法这种不设置某些值数据不会丢失

POST /test3/_doc/1/_update
{
  "doc":{
    "name":"212121"
  }
}

输出
#! Deprecation: [types removal] Specifying types in document update requests is deprecated, use the endpoint /{index}/_update/{id} instead.
{
  "_index" : "test3",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 3,
  "result" : "updated",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 2,
  "_primary_term" : 1
}

删除

DELETE /test1

输出

{
  "acknowledged" : true
}

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

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

关于文档的基本操作

基本操作

环境搭建

创建数据PUT

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


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

PUT /ming/user/3
{
  "name": "的人",
  "age": 22,
  "desc": "嘎嘎嘎",
  "tags": ["靓仔","温暖","唱歌"]
}

PUT /ming/user/4
{
  "name": "小让人",
  "age": 22,
  "desc": "嘎嘎嘎",
  "tags": ["靓仔","温暖","唱歌"]
}

获取数据GET

GET /ming/user/1

#! Deprecation: [types removal] Specifying types in document get requests is deprecated, use the /{index}/_doc/{id} endpoint instead.
{
  "_index" : "ming",
  "_type" : "user",
  "_id" : "1",
  "_version" : 3,
  "_seq_no" : 3,
  "_primary_term" : 1,
  "found" : true,
  "_source" : {
    "name" : "小小明",
    "age" : 23,
    "desc" : "一顿操作猛如虎，一看工资2500",
    "tags" : [
      "技术宅",
      "温暖",
      "直男"
    ]
  }
}

更新数据PUT

PUT /ming/user/4
{
  "name": "RR人",
  "age": 22,
  "desc": "嘎嘎嘎",
  "tags": ["靓仔","温暖","唱歌"]
}

POST —update 推荐这种修改方式

POST /ming/user/4/_update
{
  "doc":{
    "name":"众星之子"
  }
}

简单查询GET

GET /ming/user/1


#条件查询
GET /ming/user/_search?q=name:小小明

/ming的索引信息

name是type：text 所以做了分词的查询如果是keyword就不会分词搜索了

{
"version": 4,
"mapping_version": 2,
"settings_version": 1,
"aliases_version": 1,
"routing_num_shards": 1024,
"state": "open",
"settings": {
"index": {
"routing": {
"allocation": {
"include": {
"_tier_preference": "data_content"
}
}
},
"number_of_shards": "1",
"provided_name": "ming",
"creation_date": "1605849881909",
"number_of_replicas": "1",
"uuid": "GxWjNEMzRUeGYkRt_CPzXw",
"version": {
"created": "7100099"
}
}
},
"mappings": {
"user": {
"properties": {
"name": {
"type": "text",
"fields": {
"keyword": {
"ignore_above": 256,
"type": "keyword"
}
}
},
"age": {
"type": "long"
},
"desc": {
"type": "text",
"fields": {
"keyword": {
"ignore_above": 256,
"type": "keyword"
}
}
},
"tags": {
"type": "text",
"fields": {
"keyword": {
"ignore_above": 256,
"type": "keyword"
}
}
}
}
}
},
"aliases": [ ],
"primary_terms": {
"0": 1
},
"in_sync_allocations": {
"0": [
"grtHCw6jTEGFX_0NlXJ7lw"
]
},
"rollover_info": { },
"system": false
}

复杂操作搜索

条件匹配

GET /ming/user/_search
{
  "query": {
    "match": {
      "name": "小小"
    }
  }
}

过滤

结果过滤，就是只展示列表中某些字段

GET /ming/user/_search
{
  "query": {
    "match": {
      "name": "小小明"
    }
  },
  "_source": ["name","age"]
  
}

包含

GET /ming/user/_search
{
  "query": {
    "match": {
      "name": "小小明"
    }
  },
  "_source": {
    "includes": ["name","age"]
  }
  
}

不包含

GET /ming/user/_search
{
  "query": {
    "match": {
      "name": "小小明"
    }
  },
  "_source": {
    "excludes": ["name","age"]
  }
  
}

排序

GET /ming/user/_search
{
  "query": {
    "match": {
      "name": "小小明"
    }
  },
  "sort": {
    "age": {
      "order":"asc"
    }
  }
  
}
# desc   降序

分页

GET /ming/user/_search
{
  "query": {
    "match": {
      "name": "小小明"
    }
  },
  "sort": {
    "age": {
      "order":"asc"
    }
  },
  "from": 0,      
  "size": 1
  
}

from:从第几个数据开始
size：每页数据量

多条件查询

布尔值查询

must(and)

GET /ming/user/_search
{
  "query": {
    "bool": {
      "must": [
        {"match": {
      "name": "小小明"
    }
        }
      ]
    }
  }
}

should(or)

GET /ming/user/_search
{
  "query": {
    "bool": {
      "should": [
        {"match": {
      "name": "小小明"
    }
        }
      ]
    }
  }
}

must_not

GET /ming/user/_search
{
  "query": {
    "bool": {
      "must_not": [
        {"match": {
      "name": "小小明"
    }
        }
      ]
    }
  }
}

条件区间

GET /ming/user/_search
{
  "query": {
    "bool": {
      "must": [
        {"match": {
      "name": "小小明"}
        }
      ],
      "filter": [
        {
          "range": {
            "age": {
              "gte": 10,
              "lte": 26
            }
          }
        }
      ]
    }
  }
}

gt大于
gte大于等于
lte小于
lte小于等于

匹配多个条件

GET /ming/user/_search
{
  "query": {
    "match": {
      "tags": "旅游 交友 技术宅"
    }
  }
}

精确查找

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

关于分词

term，直接查询精确的
match，会使用分词器解析！（先分析文档，然后通过分析的文档进行查询）

两个类型

text keyword

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

PUT /testdb/_doc/1
{
  "name":"李子",
  "desc":"好吃"
}


PUT /testdb/_doc/2
{
  "name":"李一",
  "desc":"好发"
}

PUT /testdb/_doc/3
{
  "name":"李二",
  "desc":"分图发"
}

分析,默认被分词

GET _analyze
{
  "analyzer": "standard",
  "text": "李子树上的李子好吃"
}

输出
{
  "tokens" : [
    {
      "token" : "李",
      "start_offset" : 0,
      "end_offset" : 1,
      "type" : "<IDEOGRAPHIC>",
      "position" : 0
    },
    {
      "token" : "子",
      "start_offset" : 1,
      "end_offset" : 2,
      "type" : "<IDEOGRAPHIC>",
      "position" : 1
    },
    {
      "token" : "树",
      "start_offset" : 2,
      "end_offset" : 3,
      "type" : "<IDEOGRAPHIC>",
      "position" : 2
    },
    {
      "token" : "上",
      "start_offset" : 3,
      "end_offset" : 4,
      "type" : "<IDEOGRAPHIC>",
      "position" : 3
    },
    {
      "token" : "的",
      "start_offset" : 4,
      "end_offset" : 5,
      "type" : "<IDEOGRAPHIC>",
      "position" : 4
    },
    {
      "token" : "李",
      "start_offset" : 5,
      "end_offset" : 6,
      "type" : "<IDEOGRAPHIC>",
      "position" : 5
    },
    {
      "token" : "子",
      "start_offset" : 6,
      "end_offset" : 7,
      "type" : "<IDEOGRAPHIC>",
      "position" : 6
    },
    {
      "token" : "好",
      "start_offset" : 7,
      "end_offset" : 8,
      "type" : "<IDEOGRAPHIC>",
      "position" : 7
    },
    {
      "token" : "吃",
      "start_offset" : 8,
      "end_offset" : 9,
      "type" : "<IDEOGRAPHIC>",
      "position" : 8
    }
  ]
}

keyword 没有被分词

GET _analyze
{
  "analyzer": "keyword",
  "text": "李子树上的李子好吃"
}


输出
{
  "tokens" : [
    {
      "token" : "李子树上的李子好吃",
      "start_offset" : 0,
      "end_offset" : 9,
      "type" : "word",
      "position" : 0
    }
  ]
}

精确查询多个值

GET /testdb/_search
{
  "query": {
    "bool": {
      "should": [
        {"term": {
      "name": "小小明"
    }
        },
        {
          "term": {
            "desc": "好吃"
          }
        }
      ]
    }
  }
}

自定义高亮，搜索相关的字段可以高亮显示

GET /testdb/_search
{
  "query": {
    "bool": {
      "should": [
        {"term": {
      "name": "小小明"
    }
        },
        {
          "term": {
            "desc": "好吃"
          }
        }
      ]
    }
  },
  "highlight": {
    "pre_tags": "<a class='hehe'>",
    "post_tags": "</a>",
    "fields": {
      "desc":{}
    }
  }
}


输出
{
  "took" : 5,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 1,
      "relation" : "eq"
    },
    "max_score" : 0.9808291,
    "hits" : [
      {
        "_index" : "testdb",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 0.9808291,
        "_source" : {
          "name" : "李子",
          "desc" : "好吃"
        },
        "highlight" : {
          "desc" : [
            "<a class='hehe'>好吃</a>"
          ]
        }
      }
    ]
  }
}

Springboot集成

官网文档：https://www.elastic.co/guide/en/elasticsearch/client/index.html

引入依赖

创建一个springboot的项目同时勾选上springboot-web的包以及Nosql的elasticsearch的包

如果没有就手动引入

<!--es客户端-->
<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
    <version>7.6.2</version>
</dependency>

<!--springboot的elasticsearch服务-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>

注意下spring-boot的parent包内的依赖的es的版本是不是你对应的版本

不是的话就在pom文件下写个properties的版本

<!--这边配置下自己对应的版本-->
<properties>
    <java.version>1.8</java.version>
    <!--自己定义es版本，保证和本地的一致-->
    <elasticsearch.version>7.10.0</elasticsearch.version>
</properties>

配置客户端

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

关于索引的API操作

创建索引

import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.CreateIndexResponse;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;

@SpringBootTest
class MingEsApiApplicationTests {

	@Autowired
	@Qualifier("restHighLevelClient")
	private RestHighLevelClient client;


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

测试索引是否存在

//测试索引是否存在
@Test
void testExistIndex() throws IOException {
   //1.创建索引的请求
   GetIndexRequest request = new GetIndexRequest("ming_index");
   //2客户端执行请求，请求后获得响应
   boolean exist =  client.indices().exists(request, RequestOptions.DEFAULT);
   System.out.println("测试索引是否存在-----"+exist);
}

删除索引

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

关于文档的API操作详情

创建一个实体类

package com.company.pojo;


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

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

为使数据转化为字符串，引入fastjson

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

添加文档

//测试添加文档
   @Test
   void testAddDocument() throws IOException {
      User user = new User("ming",27);
      IndexRequest request = new IndexRequest("ming_index");
      request.id("1");
      //设置超时时间
      request.timeout("1s");
      //将数据放到json字符串
      request.source(JSON.toJSONString(user), XContentType.JSON);
      //发送请求
      IndexResponse response = client.index(request,RequestOptions.DEFAULT);
      System.out.println("添加文档-------"+response.toString());
      System.out.println("添加文档-------"+response.status());
//        结果
//        添加文档-------IndexResponse[index=lisen_index,type=_doc,id=1,version=1,result=created,seqNo=0,primaryTerm=1,shards={"total":2,"successful":1,"failed":0}]
//        添加文档-------CREATED
   }

判断文档是否存在

//测试文档是否存在
@Test
void testExistDocument() throws IOException {
   //测试文档的 没有index
   GetRequest request= new GetRequest("ming_index","1");
   //没有indices()了
   boolean exist = client.exists(request, RequestOptions.DEFAULT);
   System.out.println("测试文档是否存在-----"+exist);
}

获取文档

//测试获取文档
   @Test
   void testGetDocument() throws IOException {
      GetRequest request= new GetRequest("ming_index","1");
      GetResponse response = client.get(request, RequestOptions.DEFAULT);
      System.out.println("测试获取文档-----"+response.getSourceAsString());
      System.out.println("测试获取文档-----"+response);


   }

修改文档

//测试修改文档
   @Test
   void testUpdateDocument() throws IOException {
      User user = new User("李逍遥", 55);
      //修改是id为1的
      UpdateRequest request= new UpdateRequest("ming_index","1");
      request.timeout("1s");
      request.doc(JSON.toJSONString(user),XContentType.JSON);

      UpdateResponse response = client.update(request, RequestOptions.DEFAULT);
      System.out.println("测试修改文档-----"+response);
      System.out.println("测试修改文档-----"+response.status());

   }

删除文档

//测试删除文档
@Test
void testDeleteDocument() throws IOException {
   DeleteRequest request= new DeleteRequest("ming_index","1");
   request.timeout("1s");
   DeleteResponse response = client.delete(request, RequestOptions.DEFAULT);
   System.out.println("测试删除文档------"+response.status());
}

批量添加文档

//测试批量添加文档
   @Test
   void testBulkAddDocument() throws IOException {
      ArrayList<User> userlist=new ArrayList<User>();
      userlist.add(new User("a",5));
      userlist.add(new User("b",6));
      userlist.add(new User("c",4));
      userlist.add(new User("d",5));
      userlist.add(new User("e",61));
      userlist.add(new User("f",55));

      //批量操作的Request
      BulkRequest request = new BulkRequest();
      request.timeout("1s");

      //批量处理请求
      for (int i = 0; i < userlist.size(); i++) {
         request.add(
               new IndexRequest("ming_index")
                     .id(""+(i+1))
                     .source(JSON.toJSONString(userlist.get(i)),XContentType.JSON)
         );
      }
      BulkResponse response = client.bulk(request, RequestOptions.DEFAULT);
      //response.hasFailures()是否是失败的
      System.out.println("测试批量添加文档-----"+response.hasFailures());

   }

查询文档

	//测试查询文档
	//SearchRequest  搜索请求
	//SearchSourceBuilder  条件构造
	//HighlightBuilder   构建高亮
	//TermQueryBuilder   精确查询
	//MatchAllQueryBuilder
	//xxx QueryBuilder  对应查询的指令
   @Test
   void testSearchDocument() throws IOException {
      SearchRequest request = new SearchRequest("ming_index");
      //构建搜索条件
      SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
      //设置了高亮
      sourceBuilder.highlighter();
      //term name为a的
      TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name", "a");
      sourceBuilder.query(termQueryBuilder);
      sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));

      request.source(sourceBuilder);
      SearchResponse response = client.search(request, RequestOptions.DEFAULT);

      System.out.println("测试查询文档-----"+JSON.toJSONString(response.getHits()));
      System.out.println("=====================");
      for (SearchHit documentFields : response.getHits().getHits()) {
         System.out.println("测试查询文档--遍历参数--"+documentFields.getSourceAsMap());
      }

   }

项目实战

京东搜索：项目构建

新建springboot项目，勾选develop tool ， thymeleaf ， web， Nosql elasticsearch

修改依赖版本呢

<!--这边配置下自己对应的版本-->
<properties>
    <java.version>1.8</java.version>
    <!--自己定义es版本，保证和本地的一致-->
    <elasticsearch.version>7.10.0</elasticsearch.version>
</properties>

引入fastjson

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

springboot配置文件

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

前端文件

京东搜索：爬取数据

京东搜索实际请求https://search.jd.com/Search?keyword=java

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

解析网页jsoup包 tika包下载电影音乐

导入依赖

<!-- https://mvnrepository.com/artifact/org.jsoup/jsoup -->
<dependency>
   <groupId>org.jsoup</groupId>
   <artifactId>jsoup</artifactId>
   <version>1.13.1</version>
</dependency>

htmlparseUtil
package com.company.utils;

import com.company.pojo.Content;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;

@Component
public class HtmlParseUtil {

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

    public ArrayList<Content> parseJD(String keywords) throws IOException {
        // 获取请求,前提需要联网，ajax不能获取到！
        String url = "https://search.jd.com/Search?keyword=" + keywords + "&enc=utf-8";
        // 解析网页.（Jsoup返回的Document就是页面对象）
        Document document = Jsoup.parse(new URL(url), 30000);
        // 所有你在js中可以使用的方法
        Element element = document.getElementById("J_goodsList");
        // 获取所有的li元素
        Elements elements = element.getElementsByTag("li");
        // 获取元素中的内容,el代表每一个li标签

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

        for (Element el : elements) {
            // 关于这种图片特别多的网站，都是延迟加载的
            String image = 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(image);
            content.setPrice(price);
            goodsList.add(content);

            System.out.println("=========================");
            System.out.println(image);
            System.out.println(price);
            System.out.println(title);
        }

        return goodsList;
    }
}

config 配置

package com.company.config;

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

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

}

pojo下 content类

package com.company.pojo;


import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

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

contentservice

package com.company.service;

import com.alibaba.fastjson.JSON;
import com.company.pojo.Content;
import com.company.utils.HtmlParseUtil;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.text.Text;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.TermQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;


@Service
public class ContentService {
    @Autowired
    private RestHighLevelClient restHighLevelClient;
    
    
    // 1. 解析数据，放进es索引库中
    public Boolean parseContent(String keywords) throws IOException {
        ArrayList<Content> contents = new HtmlParseUtil().parseJD(keywords);
        // 把查询的数据放到到es中
        BulkRequest bulkRequest = new BulkRequest();
        bulkRequest.timeout("2m");

        for (int i = 0; i < contents.size(); i++) {
            bulkRequest.add(
                    new IndexRequest("jd_goods")
                            .source(JSON.toJSONString(contents.get(i)), XContentType.JSON));
        }

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

    // 2.获取数据实现搜索功能
    public List<Map<String, Object>> searchPage(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));

        // 执行搜索
        searchRequest.source(sourceBuilder);
        SearchResponse response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

        // 解析结果
        ArrayList<Map<String, Object>> list = new ArrayList<>();
        for (SearchHit hit : response.getHits().getHits()) {
            list.add(hit.getSourceAsMap());
        }
        return list;
    }

    // 3.获取数据，高亮
    public List<Map<String, Object>> searchPageHighlighter(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 response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

        // 解析结果
        ArrayList<Map<String, Object>> list = new ArrayList<>();
        for (SearchHit hit : response.getHits().getHits()) {
            // 解析高亮的字段
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            HighlightField title = highlightFields.get("title");
            Map<String, Object> map = hit.getSourceAsMap();// 原来的结果
            // 解析高亮的字段
            if (title != null) {
                // 将高亮的字段替换成原来没有高亮的字段
                Text[] fragments = title.fragments();
                String newTitle = "";
                for (Text text : fragments) {
                    newTitle += text;
                }
                map.put("title", newTitle);
            }
            list.add(map);
        }
        return list;
    }
}

controller

package com.company.controller;

import com.company.service.ContentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import java.io.IOException;
import java.util.List;
import java.util.Map;

@RestController
public class ContentController {

    @Autowired
    private ContentService contentService;

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

    @GetMapping("/search/{keyword}/{pageNo}/{pageSize}")
    public List<Map<String, Object>> search(@PathVariable("keyword") String keyword,
                                            @PathVariable("pageNo") int pageNo,
                                            @PathVariable("pageSize") int pageSize, Model model) throws IOException {

        if (pageNo == 0) {
            pageNo = 1;
        }
        System.out.println(keyword + pageNo + pageSize);
        List<Map<String, Object>> list =  contentService.searchPageHighlighter(keyword, pageNo, pageSize);
        return list;
    }

}

京东搜索：前后端交互

npm install vue              #下载vue.js
npm install axios				#下载axios.js

放入static/js下

<!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>
</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> {{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>


<!--前端使用vue,实现前后端分离-->
<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/10").then(response=>{
                   console.log(response);
                   this.results = response.data;   //绑定数据
                })
            }
        }
    });
</script>

</body>
</html>

京东搜索：高亮

// 3.获取数据，高亮
public List<Map<String, Object>> searchPageHighlighter(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 response = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

    // 解析结果
    ArrayList<Map<String, Object>> list = new ArrayList<>();
    for (SearchHit hit : response.getHits().getHits()) {
        // 解析高亮的字段
        Map<String, HighlightField> highlightFields = hit.getHighlightFields();
        HighlightField title = highlightFields.get("title");
        Map<String, Object> map = hit.getSourceAsMap();// 原来的结果
        // 解析高亮的字段
        if (title != null) {
            // 将高亮的字段替换成原来没有高亮的字段
            Text[] fragments = title.fragments();
            String newTitle = "";
            for (Text text : fragments) {
                newTitle += text;
            }
            map.put("title", newTitle);
        }
        list.add(map);
    }
    return list;
}

高亮，前端解析

<p class="productTitle">
    <a v—html="result.title"></a>
</p>

posted @ 2021-09-02 21:42 hudiaoyu2 阅读(44) 评论(0) 编辑收藏举报

刷新页面返回顶部

hudiaoyu2

搜索引擎（Elastic Search）

ElasticSearch

ElasticSearch概述

Solr和ES的对比及选型

ElasticSearch vs Solr总结

ElasticSearch安装及head插件安装

window安装

安装可视化界面 es head 的插件

Running with built in server

Kibana的安装

了解ELK

安装Kibana

ES核心概念理解

概述

文档

类型

索引

倒排索引

ik分词器

ik分词器

命令模式的使用

Rest风格说明

PUT

GET获取信息

查看默认信息

cat命令

修改

删除

关于文档的基本操作

基本操作

创建数据PUT

获取数据GET

更新数据PUT

POST —update 推荐这种修改方式

简单查询GET

复杂操作搜索

条件匹配

过滤

包含

排序

分页

多条件查询

精确查找

关于分词

Springboot集成

引入依赖

配置客户端

关于索引的API操作

创建索引

测试索引是否存在

删除索引

关于文档的API操作详情

添加文档

判断文档是否存在

获取文档

修改文档

删除文档

批量添加文档

查询文档

项目实战

京东搜索：项目构建

京东搜索：爬取数据

京东搜索：前后端交互

京东搜索：高亮

公告