淘宝、阿里、京东、腾讯等一线大厂都在用的搜索引擎技术，你确定不来看看？
一、ElasticSearch简介
1.1、什么是全文检索
全文检索是计算机程序通过扫描文章中的每一个词，对每一个词建立一个索引，指明该词在文章中出现的次数和位置。当用户查询时根据建立的索引查找，类似于通过字典的检索字表查字的过程。
检索: 索(建立索引) 检:(检索索引)
全文检索（Full-Text Retrieval(检索)）以文本作为检索对象，找出含有指定词汇的文本。全面、准确和快速是衡量全文检索系统的关键指标。
全文检索的特点：
- 只处理文本。
- 不处理语义。
- 搜索时英文不区分大小写。
- 结果列表有相关度排序。
1.2、什么是ElasticSearch
ElasticSearch 简称ES ，是基于Apache Lucene构建的开源搜索引擎，是当前流行的企业级搜索引擎。Lucene本身就可以被认为迄今为止性能最好的一款开源搜索引擎工具包，但是lucene的API相对复杂，需要深厚的搜索理论。很难集成到实际的应用中去。但是ES是采用java语言编写，提供了简单易用的RestFul API，开发者可以使用其简单的RestFul API，开发相关的搜索功能，从而避免lucene的复杂性。
1.3、ElasticSearch 的诞生
多年前，一个叫做Shay Banon的刚结婚不久的失业开发者，由于妻子要去伦敦学习厨师，他便跟着也去了。在他找工作的过程中，为了给妻子构建一个食谱的搜索引擎，他开始构建一个早期版本的Lucene。
直接基于Lucene工作会比较困难，所以Shay开始抽象Lucene代码以便Java程序员可以在应用中添加搜索功能。他发布了他的第一个开源项目，叫做“Compass”。
后来Shay找到一份工作，这份工作处在高性能和内存数据网格的分布式环境中，因此高性能的、实时的、分布式的搜索引擎也是理所当然需要的。然后他决定重写Compass库使其成为一个独立的服务叫做Elasticsearch。
第一个公开版本出现在2010年2月，在那之后Elasticsearch已经成为Github上最受欢迎的项目之一，代码贡献者超过300人。一家主营Elasticsearch的公司就此成立，他们一边提供商业支持一边开发新功能，不过Elasticsearch将永远开源且对所有人可用。
Shay的妻子依旧等待着她的食谱搜索……
1.4、ElasticSearch应用场景
ES主要以轻量级JSON作为数据存储格式，这点与MongoDB有点类似，但它在读写性能上优于 MongoDB 。同时也支持地理位置查询 ，还方便地理位置和文本混合查询 。 以及在统计、日志类数据存储和分析、可视化这方面是引领者。国内外的使用场景为：
- 国外： Wikipedia(维基百科)使用ES提供全文搜索并高亮关键字、StackOverflow(IT问答网站)结合全文搜索与地理位置查询、Github使用Elasticsearch检索1300亿行的代码。
- 国内：百度(在云分析、网盟、预测、文库、钱包、风控等业务上都应用了ES，单集群每天导入30TB+数据， 总共每天60TB+)、新浪 、阿里巴巴、腾讯等公司均有对ES的使用。
二、ElasticSearch安装
2.1、环境准备
- centos7
- jdk(1.8以上)
- ElasticSearch6.8.0
2.2、下载ElasticSearch
我们可以从官网下载ElasticSearch
wget http://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-6.8.0.tar.gz
2.3、安装JDK
2.3.1、下载JDK
# 默认位置是 /usr/java/jdk1.8.0_171-amd64*/
rpm -ivh jdk-8u181-linux-x64.rpm
2.3.2、配置环境变量
vim /etc/profile
在这个配置文件的末尾加入：
export JAVA_HOME=/usr/java/jdk1.8.0_171-amd64
export PATH=$PATH:$JAVA_HOME/bin
2.3.3、重载系统配置
source /etc/profile
2.4、ElasticSearch安装(Linux)
2.4.1、添加新的用户并且赋予权限
# 在linux系统中创建新的组
groupadd es
# 创建新的用户xialin并将es用户放入es组中
useradd xiaolin -g es
# 修改es用户密码
passwd xiaolin
# 赋予权限(给xiaolin赋予/usr文件夹下所有权限)
chown -R xiaolin /usr
2.4.2、解压
tar -zxvf elasticsearch-6.4.1.tar.gz
2.4.3、了解目录结构
- bin 可执行的二进制文件的目录
- config 配置文件的目录
- lib 运行时依赖的库
- logs 运行时日志文件
- modules 运行时依赖的模块
- plugins 可以安装官方以及第三方插件
2.4.4、启动服务
进入bin目录中启动ES服务
./elasticsearch
2.4.5、测试
默认web服务端口9200，真正的java端口（tcp端口）9300，任何身份都可以访问
# （curl相当于模拟浏览器，检测es是否安装成功且默认不允许远程链接）
curl http://localhost:9200
2.4.6、开启远程连接
注意:ES服务默认启动是受保护的,只允许本地客户端连接,如果想要通过远程客户端访问,必须开启远程连接
我们只需要
三、ElasticSearch基本概念
3.1、接近实时(NRT Near Real Time )
Elasticsearch是一个接近实时的搜索平台。这意味着，从索引一个文档直到这个文档能够被搜索到有一个轻微的延迟(通常是1秒内)
3.2、索引
ElasticSearch操作流程
- 当ElasticSearch执行添加操作时，先将数据添加到索引中，然后根据指定好的分词器规则对text类型字段进行分词。
- 字段分词之后，会得到一系列词根，ElasticSearch将这些词根保存到一张倒排索引表中，这张表会建立词根与文档之间的关联关系。
- 当用户进行全文检索的时候，输入查询语句关键词语的时候，ElasticSearch会对这个关键词语进行分词，然后根据这些去匹配倒排索引表，如果这些分词与倒排索引表词根能够匹配，那么词根关联文档的id就是满足搜索条件的文档。
- ElasticSearch会将满足搜索的文档一个一个去查询，然后进行综合评分，排序后再返回。
一个索引就是一个拥有几分相似特征的文档的集合。比如说，你可以有一个客户数据的索引，另一个产品目录的索引，还有一个订单数据的索引。一个索引由一个名字来标识(必须全部是小写字母的)，并且当我们要对这个索引中的文档进行索引、搜索、更新和删除的时候，都要使用到这个名字。索引类似于关系型数据库中Database 的概念。在一个集群中，如果你想，可以定义任意多的索引。
3.3、类型
在一个索引中，你可以定义一种或多种类型。一个类型是你的索引的一个逻辑上的分类/分区，其语义完全由你来定。通常，会为具有一组共同字段的文档定义一个类型。比如说，我们假设你运营一个博客平台并且将你所有的数 据存储到一个索引中。在这个索引中，你可以为用户数据定义一个类型，为博客数据定义另一个类型，当然，也可 以为评论数据定义另一个类型。类型类似于关系型数据库中Table的概念。 不同的版本对索引的要求也不同。
| 版本 | Type |
|---|---|
| 5.x | 支持多种 type |
| 6.x | 只能有一种 type |
| 7.x | 默认不再支持自定义索引类型（默认类型为：_doc） |
3.4、映射
Mapping是ES中的一个很重要的内容，它类似于传统关系型数据中table的schema，用于定义一个索引(index)中的类型(type)的数据的结构。 在ES中，我们可以手动创建type(相当于table)和mapping(相关与schema),也可以采用默认创建方式。在默认配置下，ES可以根据插入的数据自动地创建type及其mapping。 mapping中主要包括字段名、字段数据类型和字段索引类型
3.5、文档
**一个文档是一个可被索引的基础信息单元，类似于表中的一条记录。**比如，你可以拥有某一个员工的文档,也可以拥有某个商品的一个文档。文档以采用了轻量级的数据交换格式JSON(Javascript Object Notation)来表示。
3.6、分片
一个索引可以存储超出单个节点硬件限制的大量数据。比如，一个具有 10 亿文档数据的索引占据 1TB 的磁盘空间，而任一节点都可能没有这样大的磁盘空间。或者单个节点处理搜索请求，响应太慢。为了解决这个问题，Elasticsearch 提供了将索引划分成多份的能力，每一份就称之为分片。当你创建一个索引的时候，你可以指定你想要的分片的数量。每个分片本身也是一个功能完善并且独立的“索引”，这个“索引”可以被放置到集群中的任何节点上。
分片很重要，主要有两方面的原因：
- 允许你水平分割 / 扩展你的内容容量。
- 允许你在分片之上进行分布式的、并行的操作，进而提高性能/吞吐量。
至于一个分片怎样分布，它的文档怎样聚合和搜索请求，是完全由 Elasticsearch 管理的，对于作为用户的你来说，这些都是透明的，无需过分关心。
3.6.1、分片原理
传统的数据库每个字段存储单个值，但这对全文检索并不够。文本字段中的每个单词需要被搜索，对数据库意味着需要单个字段有索引多值的能力。最好的支持是一个字段多个值需求的数据结构是倒排索引。
Elasticsearch 使用一种称为倒排索引的结构，它适用于快速的全文搜索。
见其名，知其意，有倒排索引，肯定会对应有正向索引。正向索引（forward index），反向索引（inverted index）更熟悉的名字是倒排索引。
3.6.2、正排索引
所谓的正向索引，就是搜索引擎会将待搜索的文件都对应一个文件 ID，搜索时将这个ID 和搜索关键字进行对应，形成 K-V 对，然后对关键字进行统计计数。
但是互联网上收录在搜索引擎中的文档的数目是个天文数字，这样的索引结构根本无法满足实时返回排名结果的要求。于是倒排索引他来了！
3.6.3、倒排索引
倒排索引是把文件ID 对应到关键词的映射转换为关键词到文件ID 的映射，每个关键词都对应着一系列的文件，这些文件中都出现这个关键词。
一个倒排索引由文档中所有不重复词的列表构成，对于其中每个词，有一个包含它的文档列表。例如，假设我们有两个文档，每个文档的 content 域包含如下内容：
- The quick brown fox jumped over the lazy dog
- Quick brown foxes leap over lazy dogs in summer
为了创建倒排索引，我们首先将每个文档的 content 域拆分成单独的 词（我们称它为 词条或 tokens ），创建一个包含所有不重复词条的排序列表，然后列出每个词条出现在哪个文档。
现在，如果我们想搜索 quick和brown ，我们只需要查找包含每个词条的文档.
两个文档都匹配，但是第一个文档比第二个匹配度更高。如果我们使用仅计算匹配词条数量的简单相似性算法，那么我们可以说，对于我们查询的相关性来讲，第一个文档比第二个文档更佳。
3.7、副本
在一个网络 / 云的环境里，失败随时都可能发生，在某个分片/节点不知怎么的就处于离线状态，或者由于任何原因消失了，这种情况下，有一个故障转移机制是非常有用并且是强烈推荐的。为此目的，Elasticsearch 允许你创建分片的一份或多份拷贝，这些拷贝叫做复制分片(副本)。
复制分片之所以重要，有两个主要原因：
- 在分片/节点失败的情况下，提供了高可用性。因为这个原因，注意到复制分片从不与原/主要（original/primary）分片置于同一节点上是非常重要的。
- 扩展你的搜索量/吞吐量，因为搜索可以在所有的副本上并行运行。
四、Kibana
4.1、概述
Kibana是一个针对Elasticsearch的开源分析及可视化平台，使用Kibana可以查询、查看并与存储在ES索引的数据进行交互操作，使用Kibana能执行高级的数据分析，并能以图表、表格和地图的形式查看数据。Kibana与Elasticsearch版本保持严格一致。
4.2、下载安装Kibana
下载Kibana
下载链接
安装下载Kibana
rpm -ivh kibana-6.2.4-x86_64.rpm
查找kibana的安装位置
find / -name kibana
编辑kibana配置文件
vim /etc/kibana/kibana.yml
修改配置
#ES服务器主机地址
server.host: "192.168.202.200"
#ES服务器地址
elasticsearch.hosts: ["http://192.168.202.200:9200"]
启动kibana
# 启动kibana
systemctl start kibana
# 停止kibana
systemctl stop kibana
# 查看1kibana状态
systemctl status kibana
访问测试
kibana默认端口为5601 使用主机:端口直接访问即可 。
五、Kibana的基本操作
5.1、索引的基本操作
5.1.1、创建索引
put /student/
5.1.2、删除索引
delete /student
5.1.3、删除所有索引
delete /*
5.1.4、查看所有索引信息
get /_cat/indices?v
5.2、类型的基本操作
5.2.1、创建类型
创建/shop索引并创建(product)类型，这种方式创建类型要求索引不能存在。
PUT /shop
{
"mappings": {
"product": {
"properties": {
"title": { "type": "text" },
"name": { "type": "text" },
"age": { "type": "integer" },
"created": {
"type": "date"
}
}
}
}
}
5.2.1、查看类型
# 语法格式
get /索引名/_mapping/类型名
# 示范
get /shop/_mapping/product
5.3、文档的基本操作
5.3.1、添加文档
# /索引/类型/id
PUT /school/student/1
{
"name":"xiaolin",
"age":23,
"bir":"2012-12-12",
"content":"这是一个好一点的学生"
}
5.3.2、查询文档
GET /school/student/1
# 以下是返回结果
{
"_index": "school",
"_type": "student",
"_id": "1",
"_version": 1,
"found": true,
"_source": {
"name": "xiaolin",
"age": 23,
"bir": "2012-12-12",
"content": "这是一个好一点的学生"
}
}
5.3.3、删除文档
DELETE /school/student/1
# 以下是返回结果
{
"_index": "school",
"_type": "student",
"_id": "1",
"_version": 2,
"result": "deleted", #删除成功
"_shards": {
"total": 2,
"successful": 1,
"failed": 0
},
"_seq_no": 1,
"_primary_term": 1
}
5.3.4、更新文档
5.3.4.1、第一种方式（更新原有的数据）
POST /school/student/1/_update
{
"doc":{
"name":"xiaohei"
}
}
5.3.4.2、第二种方式（添加新数据）
POST /school/student/1/_update
{
"doc":{
"name":"xiaohei",
"age":11,
"dpet":"hello world"
}
}
六、Query高级检索
6.1、检索方式
ES官方提供了两中检索方式：
- 一种是通过 URL 参数进行搜索，类似：GET /索引/类型/_search?参数
- 一种是通过 DSL(Domain Specified Language) 进行搜索，类似：GET /索引/类型/_search {}
官方更推荐使用第二种方式，第二种方式是基于传递JSON作为请求体(request body)格式与ES进行交互，这种方式更强大，更简洁
6.2、准备数据
# 删除索引
DELETE /ems
# 创建索引并指定类型
PUT /ems
{
"mappings":{
"emp":{
"properties":{
"name":{
"type":"text"
},
"age":{
"type":"integer"
},
"bir":{
"type":"date"
},
"content":{
"type":"text"
},
"address":{
"type":"keyword"
}
}
}
}
}
# 插入测试数据
PUT /ems/emp/_bulk
{
"index":{
}}
{
"name":"小黑","age":23,"bir":"2012-12-12","content":"为开发团队选择一款优秀的MVC框架是件难事儿，在众多可行的方案中决择需要很高的经验和水平","address":"北京"}
{
"index":{
}}
{
"name":"王小黑","age":24,"bir":"2012-12-12","content":"Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式","address":"上海"}
{
"index":{
}}
{
"name":"张小五","age":8,"bir":"2012-12-12","content":"Spring Cloud 作为Java 语言的微服务框架，它依赖于Spring Boot，有快速开发、持续交付和容易部署等特点。Spring Cloud 的组件非常多，涉及微服务的方方面面，井在开源社区Spring 和Netflix 、Pivotal 两大公司的推动下越来越完善","address":"无锡"}
{
"index":{
}}
{
"name":"win7","age":9,"bir":"2012-12-12","content":"Spring的目标是致力于全方位的简化Java开发。 这势必引出更多的解释， Spring是如何简化Java开发的？","address":"南京"}
{
"index":{
}}
{
"name":"梅超风","age":43,"bir":"2012-12-12","content":"Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API","address":"杭州"}
{
"index":{
}}
{
"name":"张无忌","age":59,"bir":"2012-12-12","content":"ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口","address":"北京"}
6.3、URL检索
GET /ems/emp/_search?q=*&sort=age:asc
- _search：搜索的API
- q=* ：匹配所有文档
- sort ：以结果中的指定字段排序
- asc：排序方式（倒序or顺序）
6.4、DSL高级检索(Query)
GET /ems/emp/_search
{
"query": {"match_all": {}},
"sort": [
{
"age": {
"order": "desc"
}
}
]
}
6.4.1、match_all
这个关键字表示返回索引中的1全部文档。
GET /ems/emp/_search
{
"query": { "match_all": {} }
}
6.4.2、size
size关键字用于指定查询结果的条数，默认返回10条。
GET /ems/emp/_search
{
"query": { "match_all": {} },
"size": 1
}
6.4.3、from
from：用来指定起始返回的位置，和size连用实现分页效果。
GET /ems/emp/_search
{
"query": {"match_all": {}},
"sort": [
{
"age": {
"order": "desc"
}
}
],
"size": 2,
"from": 1
}
### 6.4.4、_source
_source是一个数组，用于指定查询结果中返回指定字段。
```markdown
GET /ems/emp/_search
{
"query": { "match_all": {} },
"_source": ["account_number", "balance"]
}
6.4.5、term
term用来使用关键词查询。
GET /ems/emp/_search
{
"query": {
"term": {
"address": {
"value": "北京"
}
}
}
}
注意事项：
- 通过使用term查询得知ES中默认使用分词器为标准分词器(StandardAnalyzer)，标准分词器对于英文单词分词十分友好，但是对于中文单字分词是非常不友好的。
- 通过使用term查询得知,在ES的Mapping Type 中 keyword , date ,integer, long , double , boolean or ip 这些类型不分词，只有text类型分词。
6.4.6、range
range用来指定查询指定范围内的文档。
GET /ems/emp/_search
{
"query": {
"range": {
"age": {
"gte": 8,
"lte": 30
}
}
}
}
6.4.7、prefix
prefix用来检索含有指定前缀的关键词的相关文档。
GET /ems/emp/_search
{
"query": {
"prefix": {
"content": {
"value": "redis"
}
}
}
}
6.4.8、wildcard
wildcard用于通配符查询：
-
？：用来匹配一个任意字符。 -
*：用来匹配任意多个字符。
GET /ems/emp/_search
{
"query": {
"wildcard": {
"content": {
"value": "re*"
}
}
}
}
6.4.9、ids
ids关键字用来根据一组id获取多个对应的文档，他的值是数组类型。
GET /ems/emp/_search
{
"query": {
"ids": {
"values": ["lg5HwWkBxH7z6xax7W3_","lQ5HwWkBxH7z6xax7W3_"]
}
}
}
6.4.10、fuzzy
fuzzy用来模糊查询含有指定关键字的文档，他有一个最大模糊错误，必须在0~2之间：
- 搜索关键词长度为2，不允许存在模糊，最大模糊错误为0。
- 搜索关键词长度为3-5，允许一次模糊，最大模糊错误为0和1。
- 搜索关键词长度大于5，最大模糊错误为2
GET /ems/emp/_search
{
"query": {
"fuzzy": {
"content":"spring"
}
}
}
6.4.11、bool
bool关键字用来组合多个条件实现复杂查询。
GET /ems/emp/_search
{
"query": {
"bool": {
"must": [
{
"range": {
"age": {
"gte": 0,
"lte": 30
}
}
}
],
"must_not": [
{"wildcard": {
"content": {
"value": "redi?"
}
}}
]
}
},
"sort": [
{
"age": {
"order": "desc"
}
}
]
}
6.4.12、highlight
highlight关键字可以让符合条件的文档中的关键词高亮，并没有对原始数据进行高亮，他是将符合高亮的文档查询出来，并加上前后缀。我们可以自定义高亮html标签：
- pre_tags：前缀
- post_tags：后缀
GET /ems/emp/_search
{
"query":{
"term":{
"content":"框架"
}
},
"highlight": {
"pre_tags": [""],
"post_tags": [""],
"fields": {
"*":{}
}
}
}
如果需要多字段高亮，可以使用require_field_match关键字将他的值设置为false开启多字段高亮。
GET /ems/emp/_search
{
"query":{
"term":{
"content":"框架"
}
},
"highlight": {
"pre_tags": [""],
"post_tags": [""],
"require_field_match":false,
"fields": {
"*":{}
}
}
}
6.4.13、multi_match
multi_match用于多字段查询，他需要注意的点：
- 如果搜索的字段分词，他会对query进行先分词再搜索。
- 如果搜索的字段不分词，他会直接使用query整体进行该字段搜索，建议在可分词的字段进行检索
GET /ems/emp/_search
{
"query": {
"multi_match": {
#搜索字段
"query": "中国",
#去哪些字段搜索
"fields": ["name","content"] #这里写要检索的指定字段
}
}
}
6.4.14、query_string
query_string用于多字段分词查询。
GET /dangdang/book/_search
{
"query": {
"query_string": {
"query": "中国声音",
"analyzer": "ik_max_word",
"fields": ["name","content"]
}
}
}
6.5、ElasticSearch底层原理
ElasticSearch的底层核心是倒排索引表。
索引区：对文档分词之后的结果，例如：name:[张:0:1] ("张"这个关键字在0号文档中出现了1次)。
元数据区：原始放入的一个个的文档。
6.5.1、正排索引
正排表是以文档的ID为关键字，表中记录文档中每个字的位置信息，查找时扫描表中每个文档中字的信息直到找出所有包含查询关键字的文档。一般是通过key，去找value。
他的结构是 ： 文档1的ID →单词1：出现次数，出现位置列表；单词2：出现次数，出现位置列表。
当用户在主页上搜索关键词“华为手机”时，假设只存在正向索引（forward index），那么就需要扫描索引库中的所有文档，找出所有包含关键词“华为手机”的文档，再根据打分模型进行打分，排出名次后呈现给用户。因为互联网上收录在搜索引擎中的文档的数目是个天文数字，这样的索引结构根本无法满足实时返回排名结果的要求。
6.5.2、倒排索引
搜索引擎会将正向索引重新构建为倒排索引，即把文件ID对应到关键词的映射转换为关键词到文件ID的映射，每个关键词都对应着一系列的文件，这些文件中都出现这个关键词。他是来利用词的关键词去找文档。
他的结构是：“关键词1”：“文档1”的ID，“文档2”的ID
七、IK分词器
ElasticSearch中采用标准分词器进行分词，这种方式并不适用于中文网站。因此需要修改ElasticSearch对中文友好分词，从而达到更佳的搜索的效果。而支持中文分词的分词器就是IK分词器。
7.1、在线安装IK分词器
将ElasticSearch服务中原始数据删除（必做）
# 进入es安装目录中将data目录数据删除
rm -rf data
安装IK分词器
# 在es安装目录中执行
./bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.8.0/elasticsearch-analysis-ik-6.8.0.zip
IK分词器要求版本严格与当前使用版本一致，如需使用其他版本替换 6.2.4 为使用的版本号。
测试
GET /_analyze
{
"text": "中华人民共和国国歌",
"analyzer": "ik_smart"
}
7.2、离线安装IK分词器
可以将对应的IK分词器下载到本地,然后再安装，官网下载地址：官网直达，下面贴一张官网给的IK分词器和ElasticSearch版本对应图。
去官网下载对应版本的IK分词器
# 可以去官网下载然后上传，或者使用wegt命令，下载其他版本的修改版本号即可。
wget https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.2.4/elasticsearch-analysis-ik-6.2.4.zip
解压
unzip elasticsearch-analysis-ik-6.2.4.zip
移动到es安装目录的plugins目录中
mv elasticsearch elasticsearch-6.2.4/plugins/
重启ElasticSearch生效
本地安装ik分词器配置目录：es安装目录中/plugins/analysis-ik/config/IKAnalyzer.cfg.xml
测试
DELETE /ems
PUT /ems
{
"mappings":{
"emp":{
"properties":{
"name":{
"type":"text",
"analyzer": "ik_max_word",
"search_analyzer": "ik_max_word"
},
"age":{
"type":"integer"
},
"bir":{
"type":"date"
},
"content":{
"type":"text",
"analyzer": "ik_max_word",
"search_analyzer": "ik_max_word"
},
"address":{
"type":"keyword"
}
}
}
}
}
PUT /ems/emp/_bulk
{"index":{}}
{"name":"小黑","age":23,"bir":"2012-12-12","content":"为开发团队选择一款优秀的MVC框架是件难事儿，在众多可行的方案中决择需要很高的经验和水平","address":"北京"}
{"index":{}}
{"name":"王小黑","age":24,"bir":"2012-12-12","content":"Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式","address":"上海"}
{"index":{}}
{"name":"张小五","age":8,"bir":"2012-12-12","content":"Spring Cloud 作为Java 语言的微服务框架，它依赖于Spring Boot，有快速开发、持续交付和容易部署等特点。Spring Cloud 的组件非常多，涉及微服务的方方面面，井在开源社区Spring 和Netflix 、Pivotal 两大公司的推动下越来越完善","address":"无锡"}
{"index":{}}
{"name":"win7","age":9,"bir":"2012-12-12","content":"Spring的目标是致力于全方位的简化Java开发。 这势必引出更多的解释， Spring是如何简化Java开发的？","address":"南京"}
{"index":{}}
{"name":"梅超风","age":43,"bir":"2012-12-12","content":"Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API","address":"杭州"}
{"index":{}}
{"name":"张无忌","age":59,"bir":"2012-12-12","content":"ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口","address":"北京"}
GET /ems/emp/_search
{
"query":{
"term":{
"content":"框架"
}
},
"highlight": {
"pre_tags": [""],
"post_tags": [""],
"fields": {
"*":{}
}
}
}
7.3、IK分词器的类型
7.3.1、ik_max_word
ik_max_word：会将文本做最细粒度的拆分，比如会将“中华人民共和国国歌”拆分为“中华人民共和国,中华人民,中华,华人,人民共和国,人民,人,民,共和国,共和,和,国国,国歌”，会穷尽各种可能的组合。
7.3.2、ik_smart
ik_smart：会做最粗粒度的拆分，比如会将“中华人民共和国国歌”拆分为“中华人民共和国,国歌”。
7.4、配置扩展词
IK支持自定义扩展词典和停用词典，所谓**扩展词典就是有些词并不是关键词,但是也希望被ES用来作为检索的关键词，可以将这些词加入扩展词典。停用词典**就是有些词是关键词,但是出于业务场景不想使用这些关键词被检索到，可以将这些词放入停用词典。词典的编码必须为UTF-8，否则无法生效。
定义扩展词典和停用词典可以修改IK分词器中config目录中IKAnalyzer.cfg.xml这个文件。
修改IKAnalyzer.cfg.xml
DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<comment>IK Analyzer 扩展配置comment>
<entry key="ext_dict">ext_dict.dicentry>
<entry key="ext_stopwords">ext_stopword.dicentry>
properties>
在ik分词器目录下config目录中创建ext_dict.dic文件
编码一定要为UTF-8才能生效。
在ext_dict.dic中加入扩展词即可
重启ElasticSearch生效
八、Filter Query过滤查询
8.1、过滤查询
其实准确来说，ElasticSearch中的查询操作分为2种:
- 查询(query)：查询即是之前提到的query查询，它 (查询)默认会计算每个返回文档的得分，然后根据得分排序。
- 过滤(filter)：过滤(filter)只会筛选出符合的文档，并不计算得分，且它可以缓存文档 。
所以，单从性能考虑，过滤比查询更快。
过滤适合在大范围筛选数据，而查询则适合精确匹配数据。一般应用时， 应先使用过滤操作过滤数据， 然后使用查询匹配数据。
8.2、过滤语法
GET /ems/emp/_search
{
"query": {
"bool": {
"must": [
{"match_all": {}}
],
"filter": {
"range": {
"age": {
"gte": 10
}
}
}
}
}
}
在执行filter和query时，先执行filter再执行query。Elasticsearch会自动缓存经常使用的过滤器，以加快性能。
8.3、过滤器类型
8.3.1、term
GET /ems/emp/_search # 使用term过滤
{
"query": {
"bool": {
"must": [
{"term": {
"name": {
"value": "小黑"
}
}}
],
"filter": {
"term": {
"content":"框架"
}
}
}
}
}
8.3.2、terms
GET /dangdang/book/_search #使用terms过滤
{
"query": {
"bool": {
"must": [
{"term": {
"name": {
"value": "中国"
}
}}
],
"filter": {
"terms": {
"content":[
"科技",
"声音"
]
}
}
}
}
}
8.3.3、range
GET /ems/emp/_search
{
"query": {
"bool": {
"must": [
{"term": {
"name": {
"value": "中国"
}
}}
],
"filter": {
"range": {
"age": {
"gte": 7,
"lte": 20
}
}
}
}
}
}
8.3.4、exists
过滤存在指定字段,获取字段不为空的索引记录使用
GET /ems/emp/_search
{
"query": {
"bool": {
"must": [
{"term": {
"name": {
"value": "中国"
}
}}
],
"filter": {
"exists": {
"field":"aaa"
}
}
}
}
}
8.3.5、ids
过滤含有指定字段的索引记录。
GET /ems/emp/_search
{
"query": {
"bool": {
"must": [
{"term": {
"name": {
"value": "中国"
}
}}
],
"filter": {
"ids": {
"values": ["1","2","3"]
}
}
}
}
}
九、Java操作ElasticSearch
ElasticSearch不能够取代数据库，ElasticSearch最核心最强大的功能时完成检索，可以把给用户查询到的数据放ElasticSearch中
9.1、引入依赖
<dependency>
<groupId>org.elasticsearchgroupId>
<artifactId>elasticsearchartifactId>
<version>6.8.0version>
dependency>
<dependency>
<groupId>org.elasticsearch.clientgroupId>
<artifactId>transportartifactId>
<version>6.8.0version>
dependency>
<dependency>
<groupId>org.elasticsearch.plugingroupId>
<artifactId>transport-netty4-clientartifactId>
<version>6.8.0version>
dependency>
9.2、创建索引和类型
PUT /dangdang
{
"mappings": {
"book":{
"properties": {
"name":{
"type":"text",
"analyzer": "ik_max_word"
},
"age":{
"type":"integer"
},
"sex":{
"type":"keyword"
},
"content":{
"type":"text",
"analyzer": "ik_max_word"
}
}
}
}
}
9.3、Java操作ElasticSearch
9.3.1、创建客户端对象
//创建ES客户端操作对象
@Test
public void init() throws UnknownHostException {
PreBuiltTransportClient preBuiltTransportClient = new PreBuiltTransportClient(Settings.EMPTY);
preBuiltTransportClient.addTransportAddress(new TransportAddress(
InetAddress.getByName("192.168.202.200"),9300));
}
9.3.2、创建索引
//创建索引
@Test
public void createIndex() throws UnknownHostException, ExecutionException, InterruptedException {
PreBuiltTransportClient preBuiltTransportClient = new PreBuiltTransportClient(Settings.EMPTY);
preBuiltTransportClient.addTransportAddress(new TransportAddress(
InetAddress.getByName("192.168.202.200"),9300));
//定义索引请求
CreateIndexRequest ems = new CreateIndexRequest("ems");
//执行索引创建
CreateIndexResponse createIndexResponse = preBuiltTransportClient.admin().indices().create(ems).get();
System.out.println(createIndexResponse.isAcknowledged());
}
9.3.3、删除索引
//删除索引
@Test
public void deleteIndex() throws UnknownHostException, ExecutionException, InterruptedException {
PreBuiltTransportClient preBuiltTransportClient = new PreBuiltTransportClient(Settings.EMPTY);
preBuiltTransportClient.addTransportAddress(new TransportAddress(
InetAddress.getByName("192.168.202.200"),9300));
//定义索引请求
DeleteIndexRequest ems = new DeleteIndexRequest("ems");
//执行索引删除
AcknowledgedResponse acknowledgedResponse = preBuiltTransportClient.admin().indices().delete(ems).get();
System.out.println(acknowledgedResponse.isAcknowledged());
}
9.3.4、创建索引和类型
//创建索引类型和映射
@Test
public void init() throws UnknownHostException, ExecutionException, InterruptedException {
PreBuiltTransportClient preBuiltTransportClient = new PreBuiltTransportClient(Settings.EMPTY);
preBuiltTransportClient.addTransportAddress(new TransportAddress(
InetAddress.getByName("192.168.202.200"),9300));
//创建索引
CreateIndexRequest ems = new CreateIndexRequest("ems");
//定义json格式映射
String json = "{\"properties\":{\"name\":{\"type\":\"text\",\"analyzer\":\"ik_max_word\"},\"age\":{\"type\":\"integer\"},\"sex\":{\"type\":\"keyword\"},\"content\":{\"type\":\"text\",\"analyzer\":\"ik_max_word\"}}}";
//设置类型和mapping
ems.mapping("emp",json, XContentType.JSON);
//执行创建
CreateIndexResponse createIndexResponse = preBuiltTransportClient.admin().indices().create(ems).get();
System.out.println(createIndexResponse.isAcknowledged());
}
9.3.5、索引一条记录
9.3.5.1、根据id索引
//索引一条文档 指定id
@Test
public void createIndexOptionId() throws JsonProcessingException {
Emp emp = new Emp("xiaolin", 18, "男", "我是xiaolin，来自中国");
String s = JSONObject.toJSONString(emp);
IndexResponse indexResponse = transportClient.prepareIndex("ems", "emp", "1").setSource(s, XContentType.JSON).get();
System.out.println(indexResponse.status());
}
9.3.5.2、自动生成id索引记录
//索引一条文档 指定id
@Test
public void createIndexOptionId() throws JsonProcessingException {
Emp emp = new Emp("XiaoLin", 18 , "男", "我是XiaoLin");
String s = JSONObject.toJSONString(emp);
IndexResponse indexResponse = transportClient.prepareIndex("ems", "emp")
.setSource(s, XContentType.JSON).get();
System.out.println(indexResponse.status());
}
9.3.6、更新索引
//更新一条记录
@Test
public void testUpdate() throws IOException {
Emp emp = new Emp();
emp.setName("明天你好");
String s = JSONObject.toJSONString(emp);
UpdateResponse updateResponse = transportClient.prepareUpdate("ems", "emp", "1")
.setDoc(s,XContentType.JSON).get();
System.out.println(updateResponse.status());
}
9.3.6、批量更新
//批量更新
@Test
public void testBulk() throws IOException {
//添加第一条记录
IndexRequest request1 = new IndexRequest("ems","emp","1");
Emp emp = new Emp("中国科技", 23, "男", "这是好人");
request1.source(JSONObject.toJSONString(emp),XContentType.JSON);
//添加第二条记录
IndexRequest request2 = new IndexRequest("ems","emp","2");
Emp emp2 = new Emp("中国科技", 23, "男", "这是好人");
request2.source(JSONObject.toJSONString(emp2),XContentType.JSON);
//更新记录
UpdateRequest updateRequest = new UpdateRequest("ems","emp","1");
Emp empUpdate = new Emp();
empUpdate.setName("中国力量");
updateRequest.doc(JSONObject.toJSONString(empUpdate),XContentType.JSON);
//删除一条记录
DeleteRequest deleteRequest = new DeleteRequest("ems","emp","2");
BulkResponse bulkItemResponses = transportClient.prepareBulk()
.add(request1)
.add(request2)
.add(updateRequest)
.add(deleteRequest)
.get();
BulkItemResponse[] items = bulkItemResponses.getItems();
for (BulkItemResponse item : items) {
System.out.println(item.status());
}
}
9.3.7、检索文档
9.3.7.1、查询所有并排序
/**
* 查询所有并排序
* ASC 升序 DESC 降序
* addSort("age", SortOrder.ASC) 指定排序字段以及使用哪种方式排序
* addSort("age", SortOrder.DESC) 指定排序字段以及使用哪种方式排序
*/
@Test
public void testMatchAllQuery() throws UnknownHostException {
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY).addTransportAddress(new TransportAddress(InetAddress.getByName("172.16.251.142"), 9300));
SearchResponse searchResponse = transportClient.prepareSearch("dangdang").setTypes("book").setQuery(QueryBuilders.matchAllQuery()).addSort("age", SortOrder.DESC).get();
SearchHits hits = searchResponse.getHits();
System.out.println("符合条件的记录数: "+hits.totalHits);
for (SearchHit hit : hits) {
System.out.print("当前索引的分数: "+hit.getScore());
System.out.print(", 对应结果:=====>"+hit.getSourceAsString());
System.out.println(", 指定字段结果:"+hit.getSourceAsMap().get("name"));
System.out.println("=================================================");
}
}
9.3.7.2、分页查询
/**
* 分页查询
* From 从那条记录开始 默认从0 开始 form = (pageNow-1)*size
* Size 每次返回多少条符合条件的结果 默认10
*/
@Test
public void testMatchAllQueryFormAndSize() throws UnknownHostException {
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY).addTransportAddress(new TransportAddress(InetAddress.getByName("172.16.251.142"), 9300));
SearchResponse searchResponse = transportClient.prepareSearch("dangdang").setTypes("book").setQuery(QueryBuilders.matchAllQuery()).setFrom(0).setSize(2).get();
SearchHits hits = searchResponse.getHits();
System.out.println("符合条件的记录数: "+hits.totalHits);
for (SearchHit hit : hits) {
System.out.print("当前索引的分数: "+hit.getScore());
System.out.print(", 对应结果:=====>"+hit.getSourceAsString());
System.out.println(", 指定字段结果:"+hit.getSourceAsMap().get("name"));
System.out.println("=================================================");
}
}
9.3.7.3、返回查询字段
/**
* 查询返回指定字段(source) 默认返回所有
* setFetchSource 参数1:包含哪些字段 参数2:排除哪些字段
* setFetchSource("*","age") 返回所有字段中排除age字段
* setFetchSource("name","") 只返回name字段
* setFetchSource(new String[]{},new String[]{})
*/
@Test
public void testMatchAllQuerySource() throws UnknownHostException {
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY).addTransportAddress(new TransportAddress(InetAddress.getByName("172.16.251.142"), 9300));
SearchResponse searchResponse = transportClient.prepareSearch("dangdang").setTypes("book").setQuery(QueryBuilders.matchAllQuery()).setFetchSource("*","age").get();
SearchHits hits = searchResponse.getHits();
System.out.println("符合条件的记录数: "+hits.totalHits);
for (SearchHit hit : hits) {
System.out.print("当前索引的分数: "+hit.getScore());
System.out.print(", 对应结果:=====>"+hit.getSourceAsString());
System.out.println(", 指定字段结果:"+hit.getSourceAsMap().get("name"));
System.out.println("=================================================");
}
}
9.3.7.8、term查询
/**
* term查询
*/
@Test
public void testTerm() throws UnknownHostException {
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY).addTransportAddress(new TransportAddress(InetAddress.getByName("172.16.251.142"), 9300));
TermQueryBuilder queryBuilder = QueryBuilders.termQuery("name","中国");
SearchResponse searchResponse = transportClient.prepareSearch("dangdang").setTypes("book").setQuery(queryBuilder).get();
}
9.3.7.9、range查询
/**
* rang查询
* lt 小于
* lte 小于等于
* gt 大于
* gte 大于等于
*/
@Test
public void testRange() throws UnknownHostException {
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY).addTransportAddress(new TransportAddress(InetAddress.getByName("172.16.251.142"), 9300));
RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("age").lt(45).gte(8);
SearchResponse searchResponse = transportClient.prepareSearch("dangdang").setTypes("book").setQuery(rangeQueryBuilder).get();
}
9.3.7.10、prefix查询
/**
* prefix 前缀查询
*
*/
@Test
public void testPrefix() throws UnknownHostException {
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY).addTransportAddress(new TransportAddress(InetAddress.getByName("172.16.251.142"), 9300));
PrefixQueryBuilder prefixQueryBuilder = QueryBuilders.prefixQuery("name", "中");
SearchResponse searchResponse = transportClient.prepareSearch("dangdang").setTypes("book").setQuery(prefixQueryBuilder).get();
}
9.3.7.11、wildcard查询
/**
* wildcardQuery 通配符查询
*
*/
@Test
public void testwildcardQuery() throws UnknownHostException {
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY).addTransportAddress(new TransportAddress(InetAddress.getByName("172.16.251.142"), 9300));
WildcardQueryBuilder wildcardQueryBuilder = QueryBuilders.wildcardQuery("name", "中*");
SearchResponse searchResponse = transportClient.prepareSearch("dangdang").setTypes("book").setQuery(wildcardQueryBuilder).get();
}
9.3.7.12、ids查询
/**
* ids 查询
*/
@Test
public void testIds() throws UnknownHostException {
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY).addTransportAddress(new TransportAddress(InetAddress.getByName("172.16.251.142"), 9300));
IdsQueryBuilder idsQueryBuilder = QueryBuilders.idsQuery().addIds("1","2");
SearchResponse searchResponse = transportClient.prepareSearch("dangdang").setTypes("book").setQuery(idsQueryBuilder).get();
}
9.3.7.13、fuzzy查询
/**
* fuzzy 模糊查询
*/
@Test
public void testFuzzy() throws UnknownHostException {
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY).addTransportAddress(new TransportAddress(InetAddress.getByName("172.16.251.142"), 9300));
FuzzyQueryBuilder fuzzyQueryBuilder = QueryBuilders.fuzzyQuery("content", "国人");
SearchResponse searchResponse = transportClient.prepareSearch("dangdang").setTypes("book").setQuery(fuzzyQueryBuilder).get();
}
9.3.7.14、bool查询
/**
* bool 布尔查询
*/
@Test
public void testBool() throws UnknownHostException {
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY).addTransportAddress(new TransportAddress(InetAddress.getByName("172.16.251.142"), 9300));
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
boolQueryBuilder.should(QueryBuilders.matchAllQuery());
boolQueryBuilder.mustNot(QueryBuilders.rangeQuery("age").lte(8));
boolQueryBuilder.must(QueryBuilders.termQuery("name","中国"));
SearchResponse searchResponse = transportClient.prepareSearch("dangdang").setTypes("book").setQuery(boolQueryBuilder).get();
}
9.3.7.15、高亮查询
/**
* 高亮查询
* .highlighter(highlightBuilder) 用来指定高亮设置
* requireFieldMatch(false) 开启多个字段高亮
* field 用来定义高亮字段
* preTags("") 用来指定高亮前缀
* postTags("") 用来指定高亮后缀
*/
@Test
public void testHighlight() throws UnknownHostException {
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY).addTransportAddress(new TransportAddress(InetAddress.getByName("172.16.251.142"), 9300));
TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name", "中国");
HighlightBuilder highlightBuilder = new HighlightBuilder();
highlightBuilder.requireFieldMatch(false).field("name").field("content").preTags("").postTags("");
SearchResponse searchResponse = transportClient.prepareSearch("dangdang").setTypes("book").highlighter(highlightBuilder).highlighter(highlightBuilder).setQuery(termQueryBuilder).get();
SearchHits hits = searchResponse.getHits();
System.out.println("符合条件的记录数: "+hits.totalHits);
for (SearchHit hit : hits) {
Map<String, Object> sourceAsMap = hit.getSourceAsMap();
Map<String, HighlightField> highlightFields = hit.getHighlightFields();
System.out.println("================高亮之前==========");
for(Map.Entry<String,Object> entry:sourceAsMap.entrySet()){
System.out.println("key: "+entry.getKey() +" value: "+entry.getValue());
}
System.out.println("================高亮之后==========");
for (Map.Entry<String,Object> entry:sourceAsMap.entrySet()){
HighlightField highlightField = highlightFields.get(entry.getKey());
if (highlightField!=null){
System.out.println("key: "+entry.getKey() +" value: "+ highlightField.fragments()[0]);
}else{
System.out.println("key: "+entry.getKey() +" value: "+entry.getValue());
}
}
}
}
十、Spring Data集成Elasticsearch
10.1、Spring Data介绍
Spring Data 是一个用于简化数据库、非关系型数据库、索引库访问，并支持云服务的开源框架。其主要目标是使得对数据的访问变得方便快捷，并支持 map-reduce 框架和云计算数据服务。 Spring Data 可以极大的简化 JPA（Elasticsearch„）的写法，可以在几乎不用写实现的情况下，实现对数据的访问和操作。除了 CRUD 外，还包括如分页、排序等一些常用的功能。Spring Data 的官网
Spring Data 常用的功能模块大致有：
10.2、Spring Data Elasticsearch介绍
Spring Data Elasticsearch 基于 spring data API 简化 Elasticsearch 操作，将原始操作Elasticsearch 的客户端 API 进行封装 。Spring Data 为 Elasticsearch 项目提供集成搜索引擎。Spring Data Elasticsearch POJO 的关键功能区域为中心的模型与 Elastichsearch 交互文档和轻松地编写一个存储索引库数据访问层。官方网站
10.3、Spring Data Elasticsearch 版本对比
目前最新 springboot 对应 Elasticsearch7.6.2，Spring boot2.3.x 一般可以兼容 Elasticsearch7.x。
10.4、集成开始
10.4.1、导入依赖
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-data-elasticsearchartifactId>
dependency>
10.4.2、编写application.proerties
# es 服务地址
elasticsearch.host=127.0.0.1
# es 服务端口
elasticsearch.port=9200
# 配置日志级别,开启 debug 日志
logging.level.com.atguigu.es=debug
10.4.3、编写实体类
// @Document:代表一个文档记录 ,indexName:用来指定索引名称,type:用来指定索引类型
@Document(indexName = "dangdang",type = "book")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Book {
// @Id:将对象中id和ES中_id映射
@Id
private String id;
// analyzer:用来指定使用哪种分词器
@Field(type = FieldType.Text,analyzer ="ik_max_word")
private String name;
// @eld:用来指定ES中的字段对应Mapping ,type:用来指定ES中存储类型
@Field(type = FieldType.Date)
@JsonFormat(pattern="yyyy-MM-dd")
private Date createDate;
@Field(type = FieldType.Keyword)
private String author;
@Field(type = FieldType.Text,analyzer ="ik_max_word")
private String content;
}
10.4.4、编写BookRepository
public interface BookRepository extends ElasticsearchRepository<Book,String> {
}
10.4.5、插入文档
这种方式根据实体类中中配置自动在ElasticSearch创建索引、类型以及映射。
@SpringBootTest(classes = Application.class)
@RunWith(SpringRunner.class)
public class TestSpringBootDataEs {
@Autowired
private BookRepository bookRespistory;
/**
* 添加索引和更新索引 id 存在更新 不存在添加
*/
@Test
public void testSaveOrUpdate(){
Book book = new Book();
book.setId("21");
book.setName("xiaolin");
book.setCreateDate(new Date());
book.setAuthor("李白");
book.setContent("这是中国的好人,这真的是一个很好的人,李白很狂");
bookRespistory.save(book);
}
}
10.4.6、删除文档
/**
* 删除一条文档
*/
@Test
public void testDelete(){
Book book = new Book();
book.setId("21");
bookRespistory.delete(book);
}
10.4.7、查询
/**
* 查询所有
*/
@Test
public void testFindAll(){
Iterable<Book> books = bookRespistory.findAll();
for (Book book : books) {
System.out.println(book);
}
}
/**
* 查询一个
*/
@Test
public void testFindOne(){
Optional<Book> byId = bookRespistory.findById("21");
System.out.println(byId.get());
}
10.4.8、查询排序
/**
* 排序查询
*/
@Test
public void testFindAllOrder(){
Iterable<Book> books = bookRespistory.findAll(Sort.by(Sort.Order.asc("createDate")));
books.forEach(book -> System.out.println(book) );
}
10.4.9、分页查询并排序
@Test
public void testSearchPage() throws IOException {
SearchRequest searchRequest = new SearchRequest();
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
sourceBuilder.from(0).size(2).sort("age", SortOrder.DESC).query(QueryBuilders.matchAllQuery());
searchRequest.indices("ems").types("emp").source(sourceBuilder);
SearchResponse search = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
SearchHit[] hits = search.getHits().getHits();
for (SearchHit hit : hits) {
System.out.println(hit.getSourceAsString());
}
}
10.4.10、高亮查询
//高亮查询
@Test
public void testHighter() throws IOException, ParseException {
SearchRequest searchRequest = new SearchRequest("ems");
List<Emp> emps = new ArrayList<>();
searchRequest.types("emp");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.termQuery("content","武侠"))//设置条件
.sort("age", SortOrder.DESC)
.from(0)//起始条数 （当前页-1）*size
.size(20)
.highlighter(new HighlightBuilder().field("*").requireFieldMatch(false).preTags(").postTags(""));
searchRequest.source(searchSourceBuilder);
SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
SearchHit[] hits = searchResponse.getHits().getHits();
for (SearchHit hit : hits) {
//原始文档
Map<String,Object> sourceAsMap = hit.getSourceAsMap();
Emp emp = new Emp();
emp.setId(hit.getId());
emp.setName(sourceAsMap.get("name").toString());
emp.setAge(Integer.parseInt(sourceAsMap.get("age").toString()));
emp.setBir(new SimpleDateFormat("yyyy-MM-dd").parse(sourceAsMap.get("bir").toString()));
emp.setContent(sourceAsMap.get("content").toString());
emp.setAddress(sourceAsMap.get("address").toString());
//高亮字段
Map<String, HighlightField> highlightFields = hit.getHighlightFields();
if (highlightFields.containsKey("content")){
emp.setContent(highlightFields.get("content").fragments()[0].toString());
}
if (highlightFields.containsKey("name")){
emp.setName(highlightFields.get("name").fragments()[0].toString());
}
if (highlightFields.containsKey("address")){
emp.setAddress(highlightFields.get("address").fragments()[0].toString());
}
emps.add(emp);
}
emps.forEach(emp -> {
System.out.println(emp.toString());
});
}
10.5、封装工具类
@Component
public class ElasticsearchUtil {
private static final Logger LOGGER = LoggerFactory.getLogger(ElasticsearchUtil.class);
@Autowired
private TransportClient transportClient;
private static TransportClient client;
/**
* @PostContruct是spring框架的注解
* spring容器初始化的时候执行该方法
*/
@PostConstruct
public void init() {
client = this.transportClient;
}
/**
* 创建索引
*
* @param index
* @return
*/
public static boolean createIndex(String index) {
if(!isIndexExist(index)){
LOGGER.info("Index is not exits!");
}
CreateIndexResponse indexResponse = client.admin().indices().prepareCreate(index).execute().actionGet();
LOGGER.info("执行建立成功？" + indexResponse.isAcknowledged());
return indexResponse.isAcknowledged();
}
/**
* 删除索引
*
* @param index
* @return
*/
public static boolean deleteIndex(String index) {
if(!isIndexExist(index)) {
LOGGER.info("Index is not exits!");
}
DeleteIndexResponse dResponse = client.admin().indices().prepareDelete(index).execute().actionGet();
if (dResponse.isAcknowledged()) {
LOGGER.info("delete index " + index + " successfully!");
} else {
LOGGER.info("Fail to delete index " + index);
}
return dResponse.isAcknowledged();
}
/**
* 判断索引是否存在
*
* @param index
* @return
*/
public static boolean isIndexExist(String index) {
IndicesExistsResponse inExistsResponse = client.admin().indices().exists(new IndicesExistsRequest(index)).actionGet();
if (inExistsResponse.isExists()) {
LOGGER.info("Index [" + index + "] is exist!");
} else {
LOGGER.info("Index [" + index + "] is not exist!");
}
return inExistsResponse.isExists();
}
/**
* 数据添加，正定ID
*
* @param jsonObject 要增加的数据
* @param index 索引，类似数据库
* @param type 类型，类似表
* @param id 数据ID
* @return
*/
public static String addData(JSONObject jsonObject, String index, String type, String id) {
IndexResponse response = client.prepareIndex(index, type, id).setSource(jsonObject).get();
LOGGER.info("addData response status:{},id:{}", response.status().getStatus(), response.getId());
return response.getId();
}
/**
* 数据添加
*
* @param jsonObject 要增加的数据
* @param index 索引，类似数据库
* @param type 类型，类似表
* @return
*/
public static String addData(JSONObject jsonObject, String index, String type) {
return addData(jsonObject, index, type, UUID.randomUUID().toString().replaceAll("-", "").toUpperCase());
}
/**
* 通过ID删除数据
*
* @param index 索引，类似数据库
* @param type 类型，类似表
* @param id 数据ID
*/
public static void deleteDataById(String index, String type, String id) {
DeleteResponse response = client.prepareDelete(index, type, id).execute().actionGet();
LOGGER.info("deleteDataById response status:{},id:{}", response.status().getStatus(), response.getId());
}
/**
* 通过ID 更新数据
*
* @param jsonObject 要增加的数据
* @param index 索引，类似数据库
* @param type 类型，类似表
* @param id 数据ID
* @return
*/
public static void updateDataById(JSONObject jsonObject, String index, String type, String id) {
UpdateRequest updateRequest = new UpdateRequest();
updateRequest.index(index).type(type).id(id).doc(jsonObject);
client.update(updateRequest);
}
/**
* 通过ID获取数据
*
* @param index 索引，类似数据库
* @param type 类型，类似表
* @param id 数据ID
* @param fields 需要显示的字段，逗号分隔（缺省为全部字段）
* @return
*/
public static Map<String,Object> searchDataById(String index, String type, String id, String fields) {
GetRequestBuilder getRequestBuilder = client.prepareGet(index, type, id);
if (StringUtils.isNotEmpty(fields)) {
getRequestBuilder.setFetchSource(fields.split(","), null);
}
GetResponse getResponse = getRequestBuilder.execute().actionGet();
return getResponse.getSource();
}
/**
* 使用分词查询,并分页
*
* @param index 索引名称
* @param type 类型名称,可传入多个type逗号分隔
* @param startPage 当前页
* @param pageSize 每页显示条数
* @param query 查询条件
* @param fields 需要显示的字段，逗号分隔（缺省为全部字段）
* @param sortField 排序字段
* @param highlightField 高亮字段
* @return
*/
public static EsPage searchDataPage(String index, String type, int startPage, int pageSize, QueryBuilder query, String fields, String sortField, String highlightField) {
SearchRequestBuilder searchRequestBuilder = client.prepareSearch(index);
if (StringUtils.isNotEmpty(type)) {
searchRequestBuilder.setTypes(type.split(","));
}
searchRequestBuilder.setSearchType(SearchType.QUERY_THEN_FETCH);
// 需要显示的字段，逗号分隔（缺省为全部字段）
if (StringUtils.isNotEmpty(fields)) {
searchRequestBuilder.setFetchSource(fields.split(","), null);
}
//排序字段
if (StringUtils.isNotEmpty(sortField)) {
searchRequestBuilder.addSort(sortField, SortOrder.DESC);
}
// 高亮（xxx=111,aaa=222）
if (StringUtils.isNotEmpty(highlightField)) {
HighlightBuilder highlightBuilder = new HighlightBuilder();
//highlightBuilder.preTags("");//设置前缀
//highlightBuilder.postTags("");//设置后缀
// 设置高亮字段
highlightBuilder.field(highlightField);
searchRequestBuilder.highlighter(highlightBuilder);
}
//searchRequestBuilder.setQuery(QueryBuilders.matchAllQuery());
searchRequestBuilder.setQuery(query);
// 分页应用
searchRequestBuilder.setFrom(startPage).setSize(pageSize);
// 设置是否按查询匹配度排序
searchRequestBuilder.setExplain(true);
//打印的内容 可以在 Elasticsearch head 和 Kibana 上执行查询
LOGGER.info("\n{}", searchRequestBuilder);
// 执行搜索,返回搜索响应信息
SearchResponse searchResponse = searchRequestBuilder.execute().actionGet();
long totalHits = searchResponse.getHits().totalHits;
long length = searchResponse.getHits().getHits().length;
LOGGER.debug("共查询到[{}]条数据,处理数据条数[{}]", totalHits, length);
if (searchResponse.status().getStatus() == 200) {
// 解析对象
List<Map<String, Object>> sourceList = setSearchResponse(searchResponse, highlightField);
return new EsPage(startPage, pageSize, (int) totalHits, sourceList);
}
return null;
}
/**
* 使用分词查询
*
* @param index 索引名称
* @param type 类型名称,可传入多个type逗号分隔
* @param query 查询条件
* @param size 文档大小限制
* @param fields 需要显示的字段，逗号分隔（缺省为全部字段）
* @param sortField 排序字段
* @param highlightField 高亮字段
* @return
*/
public static List<Map<String, Object>> searchListData(String index, String type, QueryBuilder query, Integer size, String fields, String sortField, String highlightField) {
SearchRequestBuilder searchRequestBuilder = client.prepareSearch(index);
if (StringUtils.isNotEmpty(type)) {
searchRequestBuilder.setTypes(type.split(","));
}
if (StringUtils.isNotEmpty(highlightField)) {
HighlightBuilder highlightBuilder = new HighlightBuilder();
// 设置高亮字段
highlightBuilder.field(highlightField);
searchRequestBuilder.highlighter(highlightBuilder);
}
searchRequestBuilder.setQuery(query);
if (StringUtils.isNotEmpty(fields)) {
searchRequestBuilder.setFetchSource(fields.split(","), null);
}
searchRequestBuilder.setFetchSource(true);
if (StringUtils.isNotEmpty(sortField)) {
searchRequestBuilder.addSort(sortField, SortOrder.DESC);
}
if (size != null && size > 0) {
searchRequestBuilder.setSize(size);
}
//打印的内容 可以在 Elasticsearch head 和 Kibana 上执行查询
LOGGER.info("\n{}", searchRequestBuilder);
SearchResponse searchResponse = searchRequestBuilder.execute().actionGet();
long totalHits = searchResponse.getHits().totalHits;
long length = searchResponse.getHits().getHits().length;
LOGGER.info("共查询到[{}]条数据,处理数据条数[{}]", totalHits, length);
if (searchResponse.status().getStatus() == 200) {
// 解析对象
return setSearchResponse(searchResponse, highlightField);
}
return null;
}
/**
* 高亮结果集 特殊处理
*
* @param searchResponse
* @param highlightField
*/
private static List<Map<String, Object>> setSearchResponse(SearchResponse searchResponse, String highlightField) {
List<Map<String, Object>> sourceList = new ArrayList<Map<String, Object>>();
StringBuffer stringBuffer = new StringBuffer();
for (SearchHit searchHit : searchResponse.getHits().getHits()) {
searchHit.getSourceAsMap().put("id", searchHit.getId());
if (StringUtils.isNotEmpty(highlightField)) {
System.out.println("遍历 高亮结果集，覆盖 正常结果集" + searchHit.getSourceAsMap());
Text[] text = searchHit.getHighlightFields().get(highlightField).getFragments();
if (text != null) {
for (Text str : text) {
stringBuffer.append(str.string());
}
//遍历 高亮结果集，覆盖 正常结果集
searchHit.getSourceAsMap().put(highlightField, stringBuffer.toString());
}
}
sourceList.add(searchHit.getSourceAsMap());
}
return sourceList;
}
}
十一、ElasticSearch集群
11.1、相关概念
11.1.1、集群(cluster)
一个集群就是由一个或多个节点组织在一起，它们共同持有你整个的数据，并一起提供索引和搜索功能。一个集群 由一个唯一的名字标识，这个名字默认就是elasticsearch。这个名字是重要的，因为一个节点只能通过指定某个集群的名字，来加入这个集群。在产品环境中显式地设定这个名字是一个好习惯，但是使用默认值来进行测试/开发也是不错的。
11.1.2、节点
一个节点是你集群中的一个服务器，作为集群的一部分，它存储你的数据，参与集群的索引和搜索功能。和集群类似，一个节点也是由一个名字来标识的，默认情况下，这个名字是一个随机的漫威漫画角色的名字，这个名字会在启动的时候赋予节点。这个名字对于管理工作来说挺重要的，因为在这个管理过程中，你会去确定网络中的哪些服务器对应于Elasticsearch集群中的哪些节点。
一个节点可以通过配置集群名称的方式来加入一个指定的集群。默认情况下，每个节点都会被安排加入到一个叫 做“elasticsearch”的集群中，这意味着，如果你在你的网络中启动了若干个节点，并假定它们能够相互发现彼此，它们将会自动地形成并加入到一个叫做“elasticsearch”的集群中。
在一个集群里，只要你想，可以拥有任意多个节点。而且，如果当前你的网络中没有运行任何Elasticsearch节点， 这时启动一个节点，会默认创建并加入一个叫做“elasticsearch”的集群。
11.1.3、分片和复制(shards & replicas)
一个索引可以存储超出单个结点硬件限制的大量数据。比如，一个具有10亿文档的索引占据1TB的磁盘空间，而任一节点都没有这样大的磁盘空间;或者单个节点处理搜索请求，响应太慢。为了解决这个问题，Elasticsearch提供了将索引划分成多份的能力，这些份就叫做分片。
当你创建一个索引的时候，你可以指定你想要的分片的数量。每个分片本身也是一个功能完善并且独立的“索引”，这个“索引”可以被放置 到集群中的任何节点上。 分片之所以重要，主要有两方面的原因: 允许你水平分割/扩展你的内容容量允许你在分片(潜在地，位于多个节点上)之上进行分布式的、并行的操作，进而提高性能/吞吐量 至于一个分片怎样分布，它的文档怎样聚合回搜索请求，是完全由Elasticsearch管理的，对于作为用户的你来说，这些都是透明的。
在一个网络/云的环境里，失败随时都可能发生，在某个分片/节点不知怎么的就处于离线状态，或者由于任何原因 消失了。这种情况下，有一个故障转移机制是非常有用并且是强烈推荐的。为此目的，Elasticsearch允许你创建分 片的一份或多份拷贝，这些拷贝叫做复制分片，或者直接叫复制。
复制之所以重要，主要有两方面的原因: 在分片/节点失败的情况下，提供了高可用性。因为这个原因，注意到复制分片从不与原/主要 (original/primary)分片置于同一节点上是非常重要的。 扩展你的搜索量/吞吐量，因为搜索可以在所有的复制上并行运行 。
总之，每个索引可以被分成多个分片。一个索引也可以被复制0次(意思是没有复制)或多次。一旦复制了，每个 索引就有了主分片(作为复制源的原来的分片)和复制分片(主分片的拷贝)之别。分片和复制的数量可以在索引创建的时候指定。在索引创建之后，你可以在任何时候动态地改变复制数量，但是不能改变分片的数量。
默认情况下，Elasticsearch中的每个索引被分片5个主分片和1个复制，这意味着，如果你的集群中至少有两个节点，你的索引将会有5个主分片和另外5个复制分片(1个完全拷贝)，这样的话每个索引总共就有10个分片。一个 索引的多个分片可以存放在集群中的一台主机上，也可以存放在多台主机上，这取决于你的集群机器数量。主分片和复制分片的具体位置是由ES内在的策略所决定的。
11.2、集群架构图
11.3、搭建集群
将原有ES安装包复制三份
cp -r elasticsearch-6.2.4/ master/
cp -r elasticsearch-6.2.4/ slave1/
cp -r elasticsearch-6.2.4/ slave2/
删除复制目录中data目录
# 由于复制目录之前使用过因此需要在创建集群时将原来数据删除
rm -rf master/data
rm -rf slave1/data
rm -rf slave2/data
编辑没有文件夹中config目录中jvm.options文件跳转启动内存
# 此步骤是调整启动时占JVM内存的大小，也可以关机去调整虚拟机的大小，因为一般的虚拟机都只可以启动一个elasticsearch服务，启动集群的时需要更大的内存,分别在下面配置文件中加入: -Xms512m -Xmx512m
vim master/config/jvm.options
vim slave1/config/jvm.options
vim slave2/config/jvm.options
分别修改三个文件夹中config目录中elasticsearch.yml文件
vim master/config/elasticsearch.yml
vim salve1/config/elasticsearch.yml
vim slave2/config/elasticsearch.yml
# 分别修改如下配置:
cluster.name: my-es #集群名称(集群名称必须一致)
node.name: es-03 #节点名称(节点名称不能一致)
network.host: 0.0.0.0 #监听地址(必须开启远程权限,并关闭防火墙)
http.port: 9200 #监听端口(在一台机器时服务端口不能一致)
discovery.zen.ping.unicast.hosts: ["172.30.2.175:9301", "172.30.2.201:9302"] #另外两个节点的ip
gateway.recover_after_nodes: 3 #集群可做master的最小节点数
transport.tcp.port: 9300 #集群TCP端口(在一台机器搭建必须修改) 9301 9302 9303
启动多个es
./master/bin/elasticsearch
./slave1/bin/elasticsearch
./slave2/bin/elasticsearch
查看节点状态
curl http://10.102.115.3:9200
curl http://10.102.115.3:8200
curl http://10.102.115.3:7200
查看集群健康
http://10.102.115.3:9200/_cat/health?v
11.4、安装elasticsearch-head插件
有两种方式安装elasticsearch-head插件：
- 基于Node.js的部署
- 基于Chrome浏览器插件部署
11.4.1、方式一
elasticsearch-head下载到本地
git clone git://github.com/mobz/elasticsearch-head.git
安装nodejs
# 没有wget的请先安装yum install -y wget
wget http://cdn.npm.taobao.org/dist/node/latest-v8.x/node-v8.1.2-linux-x64.tar.xz
解压缩nodejs
xz -d node-v10.15.3-linux-arm64.tar.xz 解压为tar包
配置环境变量
mv node-v10.15.3-linux-arm64 nodejs
mv nodejs /usr/nodejs
vim /etc/profile
# 在文件中书写下面两个配置，具体的路径自行更改
export NODE_HOME=/usr/nodejs
export PATH=$PATH:$JAVA_HOME/bin:$NODE_HOME/bin
进入elasticsearch-head的目录
npm config set registry https://registry.npm.taobao.org
npm install
npm run start
编写elastsearch.yml配置文件开启head插件的访问
http.cors.enabled: true
http.cors.allow-origin: "*"
启动访问head插件 默认端口9100
http://ip:9100 查看集群状态
11.4.2、基于Chrome浏览器插件
插件的百度链接：密码6666
下载插件后，到chrome的扩展程序里→打开开发者模式→加载已解压的扩展程序→上传刚才的es-head压缩包, 打开浏览器看右上角的es-head图标插件, 即安装成功。
