ElasticSearch学习笔记
本文章基于B站UP主“编程不良人” 视频教程《》进行整理记录，仅用于个人学习/交流使用。
视频教程：
参考资料：
es事务性不强，不能替换数据库
前置概念
RestFul概述
REST : 表现层状态转化(Representational State Transfer)，如果一个架构符合REST原则，就称它为 RESTful 架构风格。
资源: 所谓"资源"，就是网络上的一个实体，或者说是网络上的一个具体信息
表现层 : 我们把"资源"具体呈现出来的形式，叫做它的"表现层"(Representation)。
状态转化(State Transfer):如果客户端想要操作服务器，必须通过某种手段，让服务器端发生"状态转 化"(State Transfer)。而这种转化是建立在表现层之上的，所以就是"表现层状态转化"。
REST原则就是指一个URL代表一个唯一资源，并且通过HTTP协议里面四个动词:GET、POST、PUT、DELETE对应四种服务器端的基本操作: GET用来获取资源，POST用来添加资源(也可以用于更新资源)，PUT用来更新资源，DELETE用来删除资源。
RestFul风格编程
非Rest风格的代码：
Rest风格的代码：
Rest设计原则:
1.使用restURL替换传统URL参数作为URL整体
rest url: http: //localhost:8989/项目名/rest/findOne/21/
2.使用四种http动词(请求方式)对应服务端四种操作
@GetMapping、@PostMapping、@PutMapping、@DeleteMapping
3.通常服务返回数据都是 JSON格式 或者 XML格式
@RestController
1.标识当前服务是基于restfu的架构风格
2.@RestController = @ResponseBody + @Controller组合
在类上添加 @RestController 之后，此类的方法上不必每个类都要写 @ResponseBody
全文检索概述
全文检索是计算机程序通过扫描文章中的每一个词，对每一个词建立一个索引，指明该词在文章中出现的次数和位置。当用户查询时根据建立的索引查找，类似于通过字典的检索字表查字的过程。
检索：索(建立索引)、检(检索索引)
全文检索（Full-Text Retrieval(检索)）以文本作为检索对象，找出含有指定词汇的文本。全面、准确和快速是衡量全文检索系统的关键指标。
关于全文检索，我们要知道：
1. 只处理文本。
2. 不处理语义。
-
搜索时
英文不区分大小写 -
结果列表有
相关度排序
ElasticSearch概述与安装
什么是ElasticSearch
ElasticSearch 简称 ES，是基于Apache Lucene构建的开源搜索引擎，是当前流行的企业级搜索引擎。Lucene本身就可以被认为迄今为止性能最好的一款开源搜索引擎工具包，但是lucene的API相对复杂，需要深厚的搜索理论。很难集成到实际的应用中去。但是ES是采用java语言编写，提供了简单易用的RestFul API，开发者可以使用其简单的RestFul API，开发相关的搜索功能，从而避免lucene的复杂性。
ES的诞生
多年前，一个叫做Shay Banon的刚结婚不久的失业开发者，由于妻子要去伦敦学习厨师，他便跟着也去了。在他找工作的过程中，为了给妻子构建一个食谱的搜索引擎，他开始构建一个早期版本的Lucene。
直接基于Lucene工作会比较困难，所以Shay开始抽象Lucene代码以便Java程序员可以在应用中添加搜索功能。他发布了他的第一个开源项目，做“Compass”
后来Shay找到一份工作，这份工作处在高性能和内存数据网格的分布式环境中，因此高性能的实时的、分布式的搜索引擎也是理所当然需要的。然后他决定重写Compass库使其成为一个独立的服务叫做Elasticsearch。
第一个公开版本出现在2010年2月，在那之后Elasticsearch已经成为Github上最受欢迎的项目之一，代码贡献者超过300人。一家主营Elasticsearch的公司就此成立，他们一边提供商业支持一边开发新功能，不过Elasticsearch将永远开源且对所有人可用。
Shay的妻子依旧等待着她的食谱搜索…
ES的应用场景
ES主要以轻量级JSON作为数据存储格式，这点与MongoDB有点类似，但它在读写性能上优于 MongoDB 。同时也支持地理位置查询 ，还方便地理位置和文本混合查询 。 以及在统计、日志类数据存储和分析、可视化这方面是引领者。
国外:
Wikipedia(维基百科)使用ES提供全文搜索并高亮关键字、
StackOverflow(IT问答网站)结合全文搜索与地理位置查询、
Github使用Elasticsearch检索1300亿行的代码。
国内:
百度(在云分析、网盟、预测、文库、钱包、风控等业务上都应用了ES，单集群每天导入30TB+数据， 总共每天60TB+)、
新浪 、阿里巴巴、腾讯等公司均有对ES的使用。
使用比较广泛的平台ELK(ElasticSearch, Logstash, Kibana)
ES的安装【Docker】
docker pull elasticsearch:6.8.20
docker pull kibana:6.8.20
docker images
docker network create somenetwork
docker run -d --name elasticsearch --net somenetwork -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms256m -Xmx256m" elasticsearch:6.8.20
find / -name "kibana.yml"
vim /var/lib/docker/overlay2/0502650dfe5d47698b67d7d8637b90615fd0af20183ca7e6a825bb9172c9cde4/diff/usr/share/kibana/config/kibana.yml
docker run -d --name kibana --net somenetwork -p 5601:5601 kibana:6.8.20
docker logs -f kibana
验证elasticsearch是否安装成功：
http://192.168.228.130:9200/
验证kibana是否安装成功：
http://192.168.228.130:5601/
Kibana是一个针对Elasticsearch的开源分析及可视化平台，使用Kibana可以查询、查看并与存储在ES索引的数据进行交互操作，使用Kibana能执行高级的数据分析，并能以图表、表格和地图的形式查看数据。
Tips：你在左边缩写的语句，kibana会帮助你进行缓存，所以你不用担心kibana关闭后消失。
ES中的基本概念
接近实时(NRT Near Real Time )
Elasticsearch是一个接近实时的搜索平台。这意味着，从索引一个文档直到这个文档能够被搜索到有一个轻微的延迟 (通常是1秒内)
索引(index)
一个索引就是一个拥有几分相似特征的文档的集合。比如说，你可以有一个客户数据的索引，另一个产品目录的索引，还有一个订单数据的索引。一个索引由一个名字来标识(必须全部是小写字母的)，并且当我们要对这个索引中的文档进行索引、搜索、更新和删除的时候，都要使用到这个名字。索引类似于关系型数据库中Database 的概念。在一个集群中，如果你想，可以定义任意多的索引。
类型(type)
在一个索引中，你可以定义一种或多种类型。一个类型是你的索引的一个逻辑上的分类/分区，其语义完全由你来定。通常，会为具有一组共同字段的文档定义一个类型。比如说，我们假设你运营一个博客平台并且将你所有的数 据存储到一个索引中。在这个索引中，你可以为用户数据定义一个类型，为博客数据定义另一个类型，当然，也可 以为评论数据定义另一个类型。类型类似于关系型数据库中Table的概念。
NOTE: 在5.x版本以前可以在一个索引中定义多个类型，6.x之后版本也可以使用,但是不推荐，在7~8.x版本中彻底移除一个索引中创建多个类型
映射(Mapping)
Mapping是ES中的一个很重要的内容，它类似于传统关系型数据中table的schema(对表的约束：类型、长度、非空)，用于定义一个索引(index)中的类型(type)的数据的结构。 在ES中，我们可以手动创建type(相当于table)和mapping(相关与schema),也可以采用默认创建方式。
在默认配置下，ES可以根据插入的数据自动地创建type及其mapping。 mapping中主要包括字段名、字段数据类型和字段索引类型
文档(document)
一个文档是一个可被索引的基础信息单元，类似于表中的一条记录。比如，你可以拥有某一个员工的文档,也可以拥有某个商品的一个文档。文档以采用了轻量级的数据交换格式JSON(Javascript Object Notation)来表示。
版本变化
以上为 ES版本5 中概念。
在 ES版本6 中发生了重大的改变：
在5.x版本以前可以在一个索引中定义多个类型，6.x之后版本也可以使用,但是不推荐，在7~8.x版本中彻底移除一个索引中创建多个类型
ES基本操作
索引(Index)
# 创建索引
PUT /ems
# 创建索引（含配置信息）
PUT /ems
{
"settings": {
"number_of_replicas": 1,
"number_of_shards": 5
}
}
# 查看所有的索引
GET /_cat/indices
# 查看所有的索引（含表头信息）
# pri rep docs.count docs.deleted store.size pri.store.size
# 索引的默认主分片数量、副本分片数量、文档数、已删除的文档数、文档大小、主分片大小
# health：green 健壮、green 可用，不健壮、red 不可以
GET /_cat/indices?v
# 删除索引
DELETE /ems
# 删除所有索引
# 【谨慎使用】删除所有索引后，kibana不能正常运行（因为kibana需要 .kibana_task_manager 和 .kibana_1 ），除非重启kibana
DELETE /*
创建索引时不同版本信息：
翻译：从7.0开始时，默认的分片数量从 [5] 变成了 [1]，如果你还想使用 [5] 个分片，需要指定参数
索引必须使用：小写字母，可以使用 小写字母 + 数字
类型(type)
# 创建类型
PUT /ems
{
"mappings": {
"person":{
"properties":{
"id":{
"type":"keyword"
},
"name":{
"type":"keyword"
},
"age":{
"type":"integer"
}
}
}
}
}
# 查看索引信息(mappings+setting)
GET /ems
# 查看类型信息(mappings)
GET /ems/_mapping
说明：
“mappimgs”：映射，固定写法，即对类型的数据结构进行约束，这样在添加文档时，就会有约束
“person”：即类型名，ES6之后建议一个索引创建一个类型
“properties”：属性，固定写法，即将类型所要创建的属性添加在里面
“name”…等：属性名
“type”：固定写法，约束类型，可以根据属性的不同写不同类型
- Mapping Type: : text , keyword , date ,integer, long , double , boolean or ip
文档(document)
基本操作
# 文档操作：插入一条文档：PUT/索引/类型/文档ID
# 需要指定文档ID
PUT /ems/person/1
{
"id":"10086",
"name":"zhangsan",
"age":18
}
# 使用POST新增时
# 如果不指定ID则会自动创建一个 _id （是随机字符串，例：iU58hX0BZVIOpFfK5RDL），一般会自己创建
POST /ems/person/
{
"id":"10086",
"name":"zhangsan",
"age":18
}
# 文档操作：根据ID查询文档中的一条记录
GET /ems/person/1
# 文档操作：根据文档ID删除
DELETE /ems/person/1
更新文档
# 错误方式
POST /ems/person/1
{
"name":"李四"
}
# 查看文档:覆盖掉了原有的属性信息，只有新更新的
{
"_index" : "ems",
"_type" : "person",
"_id" : "1",
"_version" : 2,
"_seq_no" : 5,
"_primary_term" : 1,
"found" : true,
"_source" : {
"name" : "张三"
}
}
# 正确方式： 使用关键词_update
# 方式一：在原有数据基础上进行更新
# doc固定写死，这样就是先查询，在拿 doc 中数据更新
POST /ems/person/1/_update
{
"doc": {
"name":"李四"
}
}
# 第二种方式：添加新的约束的数据
# 这种方式，type并没有color属性，但你添加的时候，ES会给你进行相应的匹配
# ES `自动构建符合的类型`
POST /ems/person/1/_update
{
"doc": {
"bri":"2021-12-04"
}
}
# 第三种方式：根据script脚本进行更新[使用较少]
POST /ems/person/1/_update
{
"script": "ctx._source.age += 5.0"
}
批量操作
有时候，想要同时添加文档、删除文档、修改文档、索引文档组合进行
使用关键词 _bulk
根据关键词进行匹配，"index"创建（索引）、update更新、delete删除
【不确定】严格的JSON格式要求，JSON缩进 和 换行 要严格对应
# 同时添加多个文档
# 如果文档已经存在，则会进行覆盖
PUT /ems/person/_bulk
{"index":{"_id":"1"}}
{"id":"1","name":"张三1","age":88}
{"index":{"_id":"2"}}
{"id":"2","name":"张三2"}
{"index":{"_id":"3"}}
{"name":"张三3"}
# 同时修改和删除文档
# POST 方式 或 PUT方式 都可以
POST /ems/person/_bulk
{"update":{"_id":"1"}}
{"doc":{"name":"zhangsan"}}
{"delete":{"_id":"2"}}
{"index":{"_id":"4"}}
{"id":"4","name":"张三4","age":88}
注意：所谓批量操作，简单说就是你想进行删除操作，你就使用"delete"关键词，想要进行修改操作，你就使用"update"关键词
批量时不会因为一个失败而全部失败,而是继续执行后续操作,批量在返回时按照执行的状态开始返回
最初刚学习ElasticSearch的时候，为了便于理解，我们将其与我们所学习的MySQL数据进行了类别学习
但是ElasticSearch相对于MySQL数据库，更好的我们叫它为索引库，它分为两个过程：先是建立索引，再是检索
ElasticSearch 对于不同的服务建立了不同的索引，每个索引又创建了类型[6以后只能创建一个]，同时对类型进行了约束，现在我们往ES中索引文档，它内部是怎样工作的呢？
现在我们添加按照其类型的约束添加“张三”这条数据，ES拿到这条数据后，首先把整个文档进行储存在元数据区，同时会生成对应的"_id"，比如这里为0，到时候我们拿0去查询，就可以得到这个文档；然后按照分词器[所谓分词器就是对你输入的数据，按照一定的规则进行划分，这里以标准分词器为例]进行划分，因为name属性是"text"类型，所以需要分词，按照规则，进行单字划分，先分“张”，然后记录这个字在右边哪个文档中出现，同时出现了几次[当然这里只是简单列举一下，实际情况可能更复杂]，再分“三”，一样的操作；接下来是"age"属性，因为age是"Integer"类型，所以不需要分词，直接存储，记录。一直如此操作，直到对输入的数据完成…
现在我们要插入第二条数据，同样是现在元数据区进行储存，为其分配"_id"，然后是索引区操作，现在"张"这个字不仅在0文档出现，也出现在1文档。
需求： 现在用户想要查找address为"北京"的文档，ES会进行两次搜索，先是在索引区[分词后存放的数据]找到相匹配的文档的"id"，再是按照"id"去找到元数据区对应的文档，最后按照：比如在0文档出现的次数多，就把0文档排在前面，展示给用户。
总结： 索引库储存数据，分为索引区和元数据区，元数据区储存完整文档，索引区存放分词过后的数据
ES中的高级检索
检索方式
ES官方提供了两中检索方式：一种是通过 URL 参数进行搜索，另一种是通过 DSL(Domain Specified Language)进行搜索。
官方更推荐使用第二种方式，第二种方式是基于传递JSON作为请求体(request body)格式与ES进行交互，这种方式更强大，更简洁
语法：
- URL查询: GET /索引/类型/_search?参数
- DSL查询: GET /索引/类型/_search {}
测试数据
# 1.删除索引
DELETE /ems
# 2.创建索引并指定类型
PUT /ems
{
"mappings":{
"emp":{
"properties":{
"name":{
"type":"text"
},
"age":{
"type":"integer"
},
"bir":{
"type":"date"
},
"content":{
"type":"text"
},
"address":{
"type":"keyword"
}
}
}
}
}
# 3.插入测试数据
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":"北京"}
URL检索
【了解即可】
GET /ems/emp/_search?q=*&sort=age:desc&size=5&from=0&_source=name,age,bir
_search：搜索的API
q=* ：匹配所有文档
sort=age：按照指定字段进行排序，默认为升序，:desc 降序排列
size：展示多少条数据
from：展示第几页：from=(pageNow-1)*size
_source：只匹配哪些字段
DSL检索
【重点内容】
{
"took" : 1, # 查询所用时间，毫秒
"timed_out" : false, # 是否超时
"_shards" : { # 分片
"total" : 5, # 默认五个分片
"successful" : 5,
"skipped" : 0,
"failed" : 0
},
"hits" : { # 击中对象
"total" : 12, # 结果数
"max_score" : 1.0, # 最大得分：搜索文档的相关度（查询所有，都是1.0）（动态计算）
"hits" : [ # 查询结果
{
"_index" : "ems",
"_type" : "emp",
"_id" : "YKFmjX0BymRyKg3XALu0",
"_score" : 1.0,
"_source" : {
"name" : "梅超风",
"age" : 43
}
}
......
0.查询所有(match_all)
match_all关键字: 返回索引中的全部文档
GET /ems/emp/_search
{
"query": {
"match_all": {}
}
}
1.查询结果中返回指定条数(size)
size 关键字: 指定查询结果中返回指定条数。 默认返回值10条
是对查询的结果进行处理
GET /ems/emp/_search
{
"query": {
"match_all": {}
},
"size": 5
}
2.分页查询(from)
from 关键字: 用来指定起始返回位置，和size关键字连用可实现分页效果
GET /ems/emp/_search
{
"query": {
"match_all": {}
},
"size": 5,
"from": 0
}
3. 查询结果中返回指定字段(_source)
_source 关键字: 是一个数组,在数组中用来指定展示那些字段
# 展示单个字段
GET /ems/emp/_search
{
"query": {
"match_all": {}
},
"_source": "name"
}
# 展示多个字段
GET /ems/emp/_search
{
"query": {
"match_all": {}
},
"_source": ["name","age"]
}
4. 关键词查询(term)
term 关键字: 用来使用关键词查询
搜索时不区分大小写
type中，只有text类型是分词的，keyword integer date不分词
# name 是text类型，会进行分词，所以name包含“张”的文档都行
GET /ems/emp/_search
{
"query": {
"term": {
"name": {
"value": "张"
}
}
}
}
# bir 是date类型，不会进行分词，所以按照整体查询，查不到数据
GET /ems/emp/_search
{
"query": {
"term": {
"bir": {
"value": "2012-12"
}
}
}
}
总结：
NOTE1: 通过使用term查询得知ES中默认使用分词器为标准分词器(StandardAnalyzer),标准分词器对于英文单词分词,对于中文单字分词。
NOTE2: 通过使用term查询得知,在ES的Mapping Type 中 keyword , date ,integer, long , double , boolean or ip 这些类型不分词，只有text类型分词。
5. 范围查询(range)
range 关键字: 用来指定查询指定范围内的文档
当然只是针对一些特殊的字段比如age等
# 查询age>=5,<=10的文档
GET /ems/emp/_search
{
"query": {
"range": {
"age": {
"gte": 5,
"lte": 10
}
}
}
}
gte：大于等于
lte：小于等于
gt：大于
lt：小于
6. 前缀查询(prefix)
prefix 关键字: 用来检索含有指定前缀的关键词的相关文档
GET /ems/emp/_search
{
"query": {
"prefix": {
"name": {
"value": "无"
}
}
}
}
# 结果：
{
"took" : 11,
"timed_out" : false,
"_shards" : {
"total" : 5,
"successful" : 5,
"skipped" : 0,
"failed" : 0
},
"hits" : {
"total" : 1,
"max_score" : 1.0,
"hits" : [
{
"_index" : "ems",
"_type" : "emp",
"_id" : "BVSspHYBh-o7eO8i7bUf",
"_score" : 1.0,
"_source" : {
"name" : "张无忌",
"age" : 59,
"bir" : "2012-12-12",
"content" : "ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口",
"address" : "北京"
}
}
]
}
}
注意： 指定的前缀并不是说元数据文档中name属性以"张"为前缀的，而是匹配的经过分词器分词后索引区的数据，这里"张无忌"经过分词后为：“张”,“无”,“忌”，无论匹配到哪个都会指向那份文档
7. 通配符查询(wildcard)
wildcard 关键字: 通配符查询 ? 用来匹配一个任意字符 * 用来匹配多个任意字符
GET /ems/emp/_search
{
"query": {
"wildcard": {
"name": {
"value": "张?"
}
}
}
}
这里的匹配也是针对索引区里面的数据
一般来说，？ 和 * 一般放在文字后面，放在前面就是 查询所有
8. 多id查询(ids)
ids 关键字 : 值为数组类型,用来根据一组id获取多个对应的文档
GET /ems/emp/_search
{
"query": {
"ids": {
"values": ["AlSspHYBh-o7eO8i7bUf","BVSspHYBh-o7eO8i7bUf"]
}
}
}
9. 模糊查询(fuzzy)
最大的模糊错误，必须在0-2之间，
例如要查询到： elasticsearch，可以用：elasticsearch、elasticxearch、elasticxxarch
模糊的长度，跟字符的长度有关
长度为0…2，不允许有错误
长度为3…5，允许有一个错误
长度为>=5，允许有两个错误
fuzzy 关键字: 用来模糊查询含有指定关键字的文档
GET /ems/emp/_search
{
"query": {
"fuzzy": {
"content": "sprin"
}
}
}
# 这里搜索的关键词长度为5，允许一次模糊，索引区的数据为spring能相应匹配，刚好差1
模糊查询的规则： fuzzy 模糊查询 最大模糊错误 必须在0-2之间
- 搜索关键词长度为 2 不允许存在模糊 0
- 搜索关键词长度为3-5 允许一次模糊 0 1
- 搜索关键词长度大于5 允许最大2模糊
10. 布尔查询(bool)
bool 关键字: 用来组合多个条件实现复杂查询
- must: 相当于&& 同时成立
- should: 相当于|| 成立一个就行
- must_not: 相当于! 不能满足任何一个
GET /ems/emp/_search
{
"query": {
"bool": {
"must": [
{
"range": {
"age": {
"gte": 5,
"lte": 10
}
}
}
],
"must_not": [
{
"term": {
"address": {
"value": "南"
}
}
}
]
}
}
}
11. 高亮查询(highlight)
不属于查询，对查询结果做二次渲染
highlight 关键字: 可以让符合条件的文档中的关键词高亮
# 只高亮 name字段
GET /ems/emp/_search
{
"query": {
"term": {
"name": {
"value": "五"
}
}
},
"highlight": {
"fields": {
"name":{}
}
}
}
# 高亮所有
"highlight": {
"fields": {
"*":{}
}
}
# 结果
{
"took" : 1,
"timed_out" : false,
"_shards" : {
"total" : 5,
"successful" : 5,
"skipped" : 0,
"failed" : 0
},
"hits" : {
"total" : 1,
"max_score" : 0.2876821,
"hits" : [
{
"_index" : "ems",
"_type" : "emp",
"_id" : "AlSspHYBh-o7eO8i7bUf",
"_score" : 0.2876821,
"_source" : {
"name" : "张小五",
"age" : 8,
"bir" : "2012-12-12",
"content" : "Spring Cloud 作为Java 语言的微服务框架，它依赖于Spring Boot，有快速开发、持续交付和容易部署等特点。Spring Cloud 的组件非常多，涉及微服务的方方面面，井在开源社区Spring 和Netflix 、Pivotal 两大公司的推动下越来越完善",
"address" : "无锡"
},
"highlight" : {
"name" : [
"张小<em>五</em>"
]
}
}
]
}
}
highlight 是对查询后的结果进行高亮，所以要放在"query"之后进行，同时，并不是在原数据上进行操作，而是新增了，并增加的为
自定义高亮html标签: 可以在highlight中使用pre_tags和post_tags
GET /ems/emp/_search
{
"query": {
"term": {
"name": {
"value": "五"
}
}
},
"highlight": {
"pre_tags": ["<span style='color:red'>"],
"post_tags": ["</span>"],
"fields": {
"name":{}
}
}
}
# 结果
{
"took" : 1,
"timed_out" : false,
"_shards" : {
"total" : 5,
"successful" : 5,
"skipped" : 0,
"failed" : 0
},
"hits" : {
"total" : 1,
"max_score" : 0.2876821,
"hits" : [
{
"_index" : "ems",
"_type" : "emp",
"_id" : "AlSspHYBh-o7eO8i7bUf",
"_score" : 0.2876821,
"_source" : {
"name" : "张小五",
"age" : 8,
"bir" : "2012-12-12",
"content" : "Spring Cloud 作为Java 语言的微服务框架，它依赖于Spring Boot，有快速开发、持续交付和容易部署等特点。Spring Cloud 的组件非常多，涉及微服务的方方面面，井在开源社区Spring 和Netflix 、Pivotal 两大公司的推动下越来越完善",
"address" : "无锡"
},
"highlight" : {
"name" : [
"张小<span style='color:red'>五</span>"
]
}
}
]
}
}
12. 多字段查询(multi_match)
有时候光进行一项字段匹配体验效果并不是很好，所以可以同时多字段匹配
GET /ems/emp/_search
{
"query": {
"multi_match": {
"query": "中国", # 关键词
"fields": ["name","content"] #这里写要检索的指定字段
}
}
}
注意： 检索的关键词是否需要拆开来检索还需要看指定
的字段是否有分词
首先会对"query"进行分词，再进行分词
例如：
首先对于content可以分词，分为“北、京、Redis”，分别进行搜索
其次对于address不能分词，用“北京Redis”进行搜索
"multi_match": {
"query": "北京Redis", # 关键词
"fields": ["content","address"] #这里写要检索的指定字段
13. 多字段分词查询(query_string)
该关键词可以增加分词器
GET /dangdang/book/_search
{
"query": {
"query_string": {
"query": "中国声音",
"analyzer": "ik_max_word",
"fields": ["name","content"]
}
}
}
IK分词器
默认ES中采用标准分词器进行分词，这种方式并不适用于中文网站，因此需要修改ES对中文友好分词，从而达到更佳的搜索的效果
参考官网：
https://github.com/medcl/elasticsearch-analysis-ik
Docker安装IK
1、删除ES原始数据
因为之前可能使用的标准分词器，如果存在数据，现在又使用IK分词器会出现冲突，进入es安装目录中将data目录数据删除
docker exec -it f81 bash
rm -rf data
2、安装IK
docker exec -it f81 bash ./bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.8.20/elasticsearch-analysis-ik-6.8.20.zip
3、查看IK
安装完成后会在plugins目录下，生成IK
docker exec -it f81 bash
ls plugins/
4、重启es
5、测试
GET /_analyze
{
"text": "中华人民共和国国歌",
"analyzer": "ik_smart"
}
# 结果
{
"tokens" : [
{
"token" : "中华人民共和国",
"start_offset" : 0,
"end_offset" : 7,
"type" : "CN_WORD",
"position" : 0
},
{
"token" : "国歌",
"start_offset" : 7,
"end_offset" : 9,
"type" : "CN_WORD",
"position" : 1
}
]
}
IK分词类型
IK分词器提供了两种mapping类型用来做文档的分词分别是 ik_max_word 和 ik_smart
ik_max_word 和 ik_smart 什么区别?
- ik_max_word: 会将文本做最细粒度的拆分，比如会将“中华人民共和国国歌”拆分为“中华人民共和国,中华人民,中华,华人,人民共和国,人民,人,民,共和国,共和,和,国国,国歌”，会穷尽各种可能的组合；
- ik_smart: 会做最粗粒度的拆分，比如会将“中华人民共和国国歌”拆分为“中华人民共和国,国歌”
测试数据
建立索引的分词器 和 搜索时的分词器 保持严格一致
默认情况下就会保持一致
# 删除原有的ems索引数据
DELETE /ems
# 新建索引/类型/约束
# 同时针对属性增加了使用IK分词器
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": ["<span style='color:red'>"],
"post_tags": ["</span>"],
"fields": {
"*":{}
}
}
}
IK配置扩展词
IK支持自定义 扩展词典 和 停用词典
扩展词典： 就是有些词并不是关键词,但是也希望被ES用来作为检索的关键词,可以将这些词加入扩展词典。
停用词典： 就是有些词是关键词,但是出于业务场景不想使用这些关键词被检索到，可以将这些词放入停用词典。
配置本地词典
这里采用的本地安装：可以修改IK分词器中config目录中 IKAnalyzer.cfg.xml 这个文件
1、建分词文件
进入安装的IK分词文件的config目录下，新建 ext.dic
NOTE：
- 词典的编码必须为UTF-8，否则无法生效
- 多个词要分行放置
填入你想要扩展的词：
杠精
2、改配置文件
一定要注意ES你采用的是哪种安装方式
vim IKAnalyzer.cfg.xml
<?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">ext.dic</entry>
<!--用户可以在这里配置自己的扩展停止词字典-->
<entry key="ext_stopwords"></entry>
</properties>
3、重启ES
删除之前的数据 rm -rf data
重启
4、测试
GET /_analyze
{
"text":"碰瓷",
"analyzer": "ik_max_word"
}
# 结果
{
"tokens" : [
{
"token" : "碰瓷",
"start_offset" : 0,
"end_offset" : 2,
"type" : "CN_WORD",
"position" : 0
}
]
}
配置的扩展器只针对配置过后索引的文档有效，之前已经索引的文档想要使用改扩展词，需要重新索引
如何停用
操作和扩展一样，只是文件名在IKAnalyzer.cfg.xml中填入的位置不一样
配置远程词典
本地词典写入的词一旦写入，后面再想去填入或者停用，比较麻烦
比如，我这个博客网站我想根据用户输入的词的搜索达到多少后将其认定为热词添加到词典中，并且一段时间后进行一定的更新
EMS这个应用就相当于我们的博客，在这个下面我们创建了一个文件ext.txt，专门用于存放热词，而这个热词具体怎么来，我们可以结合redis，当用户搜索词的次数达到多少，我们通过IO写入这个文件中，然后ES通过监听url这个地址上的数据发生了变化，就进行相应的更新
1、建SpringBoot应用
2、改项目访问路径
想要访问到静态资源，需要修改一下配置
3、测试访问项目
之前我们一直使用localhost访问本地，但是后面需要在Linux端访问，所以需要用windows的ip地址：
使用：ipconfig查看
http://192.168.77.1:8888/ext.txt
4、改ES配置文件
vim IKAnalyzer.cfg.xml
<?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">ex.dic</entry>
<!--用户可以在这里配置自己的扩展停止词字典-->
<entry key="ext_stopwords"></entry>
<!--用户可以在这里配置远程扩展字典 -->
<entry key="remote_ext_dict">http://192.168.77.1:8888/ext.txt</entry>
<!--用户可以在这里配置远程扩展停止词字典-->
<entry key="remote_ext_stopwords">http://192.168.77.1:8888/stop.txt</entry>
</properties>
5、重启ES
./elasticsearch
6、测试
GET /_analyze
{
"text":"打工人",
"analyzer": "ik_max_word"
}
# 结果
{
"tokens" : [
{
"token" : "打工人",
"start_offset" : 0,
"end_offset" : 3,
"type" : "CN_WORD",
"position" : 0
},
{
"token" : "打工",
"start_offset" : 0,
"end_offset" : 2,
"type" : "CN_WORD",
"position" : 1
},
{
"token" : "工人",
"start_offset" : 1,
"end_offset" : 3,
"type" : "CN_WORD",
"position" : 2
}
]
}
发现"打工人"这个词作为分词关键词了
继续测试：
1.我们在文本文件中添加一个新的词汇
2.等待SpringBoot项目相应（重启项目 或 热部署）
3.创建包含此词汇的文档
4.使用关键词查询该文档
5.注： 只有在新的词汇添加后的文档，才会为该词汇创建索引
下面我们试试停用分词
我们将"打工"这个词停用
在stop.txt中写入：
打工
重启springboot项目
我们看一下ES界面的变化，它会去拉取远程需要加入或者停用的词到字典中
kibana 中测试：
GET /_analyze
{
"text":"打工人",
"analyzer": "ik_max_word"
}
# 结果
{
"tokens" : [
{
"token" : "打工人",
"start_offset" : 0,
"end_offset" : 3,
"type" : "CN_WORD",
"position" : 0
},
{
"token" : "工人",
"start_offset" : 1,
"end_offset" : 3,
"type" : "CN_WORD",
"position" : 1
}
]
}
发现就没有将"打工"这个词作为分词关键字了
Filter Query【过滤查询】
是什么
准确来说，ES中的查询操作分为2种: 查询(query)和过滤(filter)
查询即是之前提到的query查询，它 (查询)默认会计算每个返回文档的得分，然后根据得分排序。而过滤(filter)只会筛选出符合的文档，并不计算 得分，且它可以缓存文档 。所以，单从性能考虑，过滤比查询更快。
换句话说，过滤适合在大范围筛选数据，而查询则适合精确匹配数据。一般应用时， 应先使用过滤操作过滤数据， 然后使用查询匹配数据。
Filter Query(过滤查询)：不会计算文档得分，只做一个筛选操作
Filter 和 Query 是两种操作，他们之间使用 boolean连接
过滤语法
NOTE:
- 在执行filter和query时,先执行filter在执行query
- Elasticsearch会自动缓存经常使用的过滤器，以加快性能
- 使用过滤查询必须使用bool查询
GET /ems/emp/_search
{
"query": {
"bool": {
"must": [
{
"term": {
"name": {
"value": "小五"
}
}
}
],
"filter": {
"range": {
"age": {
"gte": 1,
"lte": 10
}
}
}
}
}
}
执行过程：
先从ES从执行过滤查询，找到符合年龄范围在[1,10]的文档，这个过程不会计算得分，
然后再执行查询操作，从满足条件的这些文档中又去查找"name"属性的值为"小五"的文档，并将可能的文档计算的得分。
常见的过滤器类型
term Filter
term 用在过滤中查询，表示查询指定字段含有该词的文档
GET /ems/emp/_search
{
"query": {
"bool": {
"must": [
{
"term": {
"name": {
"value": "小五"
}
}
}
],
"filter": {
"term": {
"content": "spring"
}
}
}
}
}
terms Filter
term只能匹配一个字段，要想过滤多个字段，使用terms
GET /ems/emp/_search
{
"query": {
"bool": {
"must": [
{
"term": {
"name": {
"value": "小五"
}
}
}
],
"filter": {
"terms": {
"content": ["spring","java"]
}
}
}
}
}
range Filter
顾名思义：就是先查找满足某个指定范围的字段
GET /ems/emp/_search
{
"query": {
"bool": {
"must": [
{
"term": {
"name": {
"value": "小五"
}
}
}
],
"filter": {
"range": {
"age": {
"gte": 1,
"lte": 10
}
}
}
}
}
}
exists Filter
过滤存在指定字段，获取字段不为空的索引记录使用
GET /ems/emp/_search
{
"query": {
"bool": {
"must": [
{
"match_all": {}
}
],
"filter": {
"exists": {
"field": "age"
}
}
}
}
}
ids Filter
查找含有指定字段的索引记录
GET /ems/emp/_search
{
"query": {
"bool": {
"must": [
{
"match_all": {}
}
],
"filter": {
"ids": {
"values": [
"1","OY0TqnYB5vZ1Et4zupDf"
]
}
}
}
}
}
Java 操作ElasticSearch
使用Java操作ES说明
实时索引：强一致性，数据库变化，es变化，完全一致
最终索引：最终一致性，过了一段时间之后，最终数据一致
最终数据一致性：
B站UP主视频播放信息统计，（只显示前一天为止的数据统计，一天更新一次）
环境搭建
1.建项目
2.改pom
引入依赖：
<dependency>
<groupId>org.elasticsearch</groupId>
<artifactId>elasticsearch</artifactId>
<version>6.8.20</version>
</dependency>
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>transport</artifactId>
<version>6.8.20</version>
</dependency>
<dependency>
<groupId>org.elasticsearch.plugin</groupId>
<artifactId>transport-netty4-client</artifactId>
<version>6.8.20</version>
</dependency>
<!--json格式转化-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.75</version>
</dependency>
3.建测试类
快捷键：ctrl + shift + t
索引相关操作
开始我们使用 kibana 客户端进行ES的操作
类比Kibana客户端的方式创建以下数据：
# 创建索引/类型、映射
# name 和 content 属性使用IK进行分词
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":"北京"}
创建 ES 客户端
Java连接的端口是 9300
//创建 ES 客户端操作对象
@Test
public void testJavaClient() throws UnknownHostException {
//创建连接
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
// Kibanan连接ES的端口为9200,Java 连接ES的方式为TCP,所以使用的端口为9300
transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"),9300));
//ES相关操作
//关闭连接
transportClient.close();
}
开启测试，如果没有报错，就代表我们的连接成功！
创建索引
@Test
public void testIndex() throws UnknownHostException, ExecutionException, InterruptedException {
//创建连接
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"),9300));
//创建索引：需要一个CreateIndexRequest 请求
CreateIndexRequest indexRequest = new CreateIndexRequest("ems");
CreateIndexResponse response = transportClient.admin().indices().create(indexRequest).get();
System.out.println(response.isAcknowledged());//查看创建结果
//关闭连接
transportClient.close();
}
创建索引/类型/映射
一般我们是自己创建索引，然后操作文档
我们在kibana中定义索引/类型/映射，而这里索引和类型都通过api实现了，只需要我们定义映射，即
properties部分，要注意这里映射的格式必须是json格式，同时如果你从上面给的数据进行复制的话，还需要对其进行压缩。
@Test
public void testIndexAndType() throws UnknownHostException, ExecutionException, InterruptedException {
//创建连接
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"),9300));
//创建索引
CreateIndexRequest indexRequest = new CreateIndexRequest("ems");
//定义json格式的映射
String mappingJson = "{\"properties\":{\"name\":{\"type\":\"text\",\"analyzer\":\"ik_max_word\"},\"age\":{\"type\":\"integer\"},\"sex\":{\"type\":\"keyword\"},\"content\":{\"type\":\"text\",\"analyzer\":\"ik_max_word\"}}}";
indexRequest.mapping("emp",mappingJson, XContentType.JSON);
//创建类型和映射
CreateIndexResponse response = transportClient.admin().indices().create(indexRequest).get();
System.out.println(response.isAcknowledged());//查看创建结果
//关闭连接
transportClient.close();
}
删除索引
@Test
public void testDeleteIndex() throws UnknownHostException, ExecutionException, InterruptedException {
//创建连接
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"),9300));
//删除索引:需要一个DeleteIndexRequest请求
DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("ems");
AcknowledgedResponse response = transportClient.admin().indices().delete(deleteIndexRequest).get();
System.out.println(response.isAcknowledged());
//关闭连接
transportClient.close();
}
文档相关操作
指定id索引文档
在kibana中我们索引文档时，可以指定id，也可以随机生成
@Test
public void testIndexDocument() throws UnknownHostException, ExecutionException, InterruptedException {
//创建连接
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
//指定id索引一条记录
Emp emp = new Emp("1", "小肥羊", 18, new Date(), "小肥羊是一只单纯的羊,他很单纯！", "北京");
String json = JSONObject.toJSONString(emp);
//参数：索引、类型、自定义ID 文档数据JSON格式，指定JSON类型
IndexResponse indexResponse = transportClient.prepareIndex("ems", "emp", emp.getId()).setSource(json, XContentType.JSON).get();
System.out.println(indexResponse.status());
//关闭连接
transportClient.close();
}
注意： 索引文档时，需要json格式
自定生成id索引文档
prepareIndex 时不传入第三个参数即可，ES会随机生成一个id
@Test
public void testIndexDocument() throws UnknownHostException, ExecutionException, InterruptedException {
//创建连接
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
//指定id索引一条记录
Emp emp = new Emp(null, "棒棒娃", 20, new Date(), "棒棒娃是一只努力的人,他很努力！", "重庆");
String s = JSONObject.toJSONString(emp);
IndexResponse indexResponse = transportClient.prepareIndex("ems", "emp").setSource(s, XContentType.JSON).get();
System.out.println(indexResponse.status());
//关闭连接
transportClient.close();
}
更新一条文档
我们需要保持原有文档数据不变，在此基础上进行更新
@Test
public void testUpdateDocument() throws UnknownHostException, ExecutionException, InterruptedException {
//创建连接
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
//更新文档
Emp emp = new Emp();
emp.setContent("帮帮娃今天去四川了！");
String s = JSONObject.toJSONString(emp);
UpdateResponse updateResponse = transportClient.prepareUpdate("ems","emp","1").setDoc(s,XContentType.JSON).get();
System.out.println(updateResponse.status());
//关闭连接
transportClient.close();
}
setDoc 表示原有数据文档不变
JSON设置日期格式：
删除一条文档
传入我们所需要删除文档的id即可
@Test
public void testDeleteDocument() throws UnknownHostException, ExecutionException, InterruptedException {
//创建连接
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
//删除文档
DeleteResponse deleteResponse = transportClient.prepareDelete("ems", "emp", "QqCqr3YBWFsguNUCcwL1").get();
System.out.println(deleteResponse.status());
//关闭连接
transportClient.close();
}
查询一条文档
getReponse 获取的是 map对象，可以转为String，即 getResponse.getSourceAsString
获取map对象之后，可以把数据手动还原回去，其中要注意 日期格式
查询所有文档
关键词查询文档 term
批量操作文档
@Test
public void testBulkDocument() throws UnknownHostException, ExecutionException, InterruptedException {
//创建连接
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
//批量处理
//1.添加文档
IndexRequest indexRequest = new IndexRequest("ems","emp","3");
Emp emp = new Emp("2", "小飞", 30, new Date(), "小飞飞往太空", "太空");
String s = JSONObject.toJSONString(emp);
indexRequest.source(s, XContentType.JSON);
//2.更新文档
UpdateRequest updateRequest = new UpdateRequest("ems","emp","1");
Emp emp1 = new Emp();
emp1.setName("中国军人");
String s1 = JSONObject.toJSONString(emp1);
updateRequest.doc(s, XContentType.JSON);
//3.删除文档
DeleteRequest deleteRequest = new DeleteRequest("ems", "emp", "1");
//将需要执行的操作加入构建的bulk中:add可以添加多个
BulkResponse itemResponses = transportClient.prepareBulk()
.add(indexRequest)
.add(updateRequest)
.add(deleteRequest)
.get();
//ES批量操作不支持原子性：可以成功,可以失败
BulkItemResponse[] items = itemResponses.getItems();
for (BulkItemResponse b : items) {
System.out.println(b.status());
}
//关闭连接
transportClient.close();
}
检索
1. 查询所有并排序
查询所有并排序
- ASC 升序 DESC 降序
- addSort(“age”, SortOrder.ASC) 指定排序字段以及使用哪种方式排序
- addSort(“age”, SortOrder.DESC) 指定排序字段以及使用哪种方式排序
打印查询结果：
@Test
public void testQueryMathAll() throws UnknownHostException, ExecutionException, InterruptedException {
//创建连接
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
//查询所有文档
SearchResponse searchResponse = transportClient.prepareSearch("ems")//索引
.setTypes("emp")//类型
.setQuery(QueryBuilders.matchAllQuery()) //查询所有
.addSort("age", SortOrder.DESC) //====>
.get();//开始查询
System.out.println("符合条件的总条数:" + searchResponse.getHits().getTotalHits());
System.out.println("最高得分:" + searchResponse.getHits().getMaxScore());
System.out.println("详细记录如下：");
SearchHit[] hits = searchResponse.getHits().getHits();
for (SearchHit h:hits) {
System.out.println("当前索引分数:" + h.getScore());
System.out.println("[字符串形式打印]====>" + h.getSourceAsString());
System.out.println("[map集合形式打印]====>" + h.getSourceAsMap());
}
//关闭连接
transportClient.close();
}
注意：
- 如果按照指定字段进行排序展示，就打乱了分数排序的规则，其分数就会失效
如果想要将查询的结果进行封装，可以这样做：将结果映射返回到对象中
@Test
public void testQueryMathAll() throws UnknownHostException, ExecutionException, InterruptedException {
List<Emp> list = new ArrayList<>();
//创建连接
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
//查询所有文档
SearchResponse searchResponse = transportClient.prepareSearch("ems")//索引
.setTypes("emp")//类型
.setQuery(QueryBuilders.matchAllQuery()) //查询所有
.addSort("age", SortOrder.DESC) //结果排序
.get();//开始查询
System.out.println("符合条件的总条数:" + searchResponse.getHits().getTotalHits());
System.out.println("最高得分:" + searchResponse.getHits().getMaxScore());
System.out.println("详细记录如下：");
SearchHit[] hits = searchResponse.getHits().getHits();
for (SearchHit h:hits) {
System.out.println("当前索引分数:" + h.getScore());
System.out.println("[字符串形式打印]====>" + h.getSourceAsString());
System.out.println("[map集合形式打印]====>" + h.getSourceAsMap());
Emp emp = new Emp();//=====>
emp.setName((String) h.getSourceAsMap().get("name"));
emp.setContent((String) h.getSourceAsMap().get("content"));
list.add(emp);
}
System.out.println(list);
//关闭连接
transportClient.close();
}
2. From Size分页查询
分页查询
- From 从那条记录开始 默认从0 开始 from = (pageNow-1)*size
- Size 每次返回多少条符合条件的结果 默认10
注意是将查询后的结果进行分页
@Test
public void testQueryFromAndSize() throws UnknownHostException, ExecutionException, InterruptedException {
//创建连接
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
//查询所有文档
SearchResponse searchResponse = transportClient.prepareSearch("ems")//索引
.setTypes("emp")//类型
.setQuery(QueryBuilders.matchAllQuery()) //传入查询的类型
.setFrom(0) //====>
.setSize(2)
.get();//开始查询
System.out.println("符合条件的总条数:" + searchResponse.getHits().getTotalHits());
System.out.println("最高得分:" + searchResponse.getHits().getMaxScore());
System.out.println("详细记录如下：");
SearchHit[] hits = searchResponse.getHits().getHits();
for (SearchHit h : hits) {
System.out.println("当前索引分数:" + h.getScore());
System.out.println("[字符串形式打印]====>" + h.getSourceAsString());
System.out.println("[map集合形式打印]====>" + h.getSourceAsMap());
}
//关闭连接
transportClient.close();
}
3. source 查询返回字段
/**
* 查询返回指定字段(source) 默认返回所有:
* setFetchSource 参数1:包含哪些字段 参数2:排除哪些字段
* setFetchSource("*","age") 返回所有字段中排除age字段
* setFetchSource("name","") 只返回name字段
* setFetchSource(new String[]{},new String[]{})
*/
@Test
public void testQuerySource() throws UnknownHostException, ExecutionException, InterruptedException {
//创建连接
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
//查询所有文档
SearchResponse searchResponse = transportClient.prepareSearch("ems")//索引
.setTypes("emp")//类型
.setQuery(QueryBuilders.matchAllQuery()) //传入查询的类型
.setFetchSource("*","age") //====>
.get();//开始查询
System.out.println("符合条件的总条数:" + searchResponse.getHits().getTotalHits());
System.out.println("最高得分:" + searchResponse.getHits().getMaxScore());
System.out.println("详细记录如下：");
SearchHit[] hits = searchResponse.getHits().getHits();
for (SearchHit h : hits) {
System.out.println("当前索引分数:" + h.getScore());
System.out.println("[字符串形式打印]====>" + h.getSourceAsString());
System.out.println("[map集合形式打印]====>" + h.getSourceAsMap());
}
//关闭连接
transportClient.close();
}
3.5 方法模板
后面几个由于其写法大致差不多，只是传入查询的类型不一样，我将其封装为一个方法，到时候根据查询的不同传入不同的参数即可
public void queryTemplate(QueryBuilder query) throws UnknownHostException {
//创建连接
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
//查询所有文档
SearchResponse searchResponse = transportClient.prepareSearch("ems")//索引
.setTypes("emp")//类型
.setQuery(query) //传入查询的类型
.get();//开始查询
System.out.println("符合条件的总条数:" + searchResponse.getHits().getTotalHits());
System.out.println("最高得分:" + searchResponse.getHits().getMaxScore());
System.out.println("详细记录如下：");
SearchHit[] hits = searchResponse.getHits().getHits();
for (SearchHit h : hits) {
System.out.println("当前索引分数:" + h.getScore());
System.out.println("[字符串形式打印]====>" + h.getSourceAsString());
System.out.println("[map集合形式打印]====>" + h.getSourceAsMap());
}
//关闭连接
transportClient.close();
}
4. term 指定查询
查询指定字段含有指定值
@Test
public void testTermQuery() throws UnknownHostException {
TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name", "飞");
queryTemplate(termQueryBuilder);
}
5. range 范围查询
/**
* rang查询
* lt 小于
* lte 小于等于
* gt 大于
* gte 大于等于
*/
@Test
public void testRange() throws UnknownHostException {
RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("age").gte(10).lte(20);
queryTemplate(rangeQueryBuilder);
}
6.prefix 前缀查询
查询指定属性[根据是否分词后的结果]是否含有指定的前缀
@Test
public void testPrefix() throws UnknownHostException {
PrefixQueryBuilder prefixQueryBuilder = QueryBuilders.prefixQuery("name", "小");
queryTemplate(prefixQueryBuilder);
}
7.wildcard 通配符查询
根据通配符类型进行补全后查询
- ? ：补全一个字符
- *：补全任意字符
@Test
public void testWildcardQuery() throws UnknownHostException {
WildcardQueryBuilder wildcardQuery = QueryBuilders.wildcardQuery("content", "小*");
queryTemplate(wildcardQuery);
}
8.Ids 指定id查询
注意：这里要查询的id紧跟后面书写
@Test
public void testIds() throws UnknownHostException {
IdsQueryBuilder queryBuilder = QueryBuilders.idsQuery().addIds("1","3");
queryTemplate(queryBuilder);
}
9.fuzzy 模糊查询
根据查询的大小，可以模糊不同的个数
- 查询的个数0-2：必须和ES的词条完全匹配
- 3-5：可以模糊一个
- 大于5：可以模糊两个
Test
public void testFuzzy() throws UnknownHostException {
FuzzyQueryBuilder fuzzyQueryBuilder = QueryBuilders.fuzzyQuery("content", "努力");
queryTemplate(fuzzyQueryBuilder);
}
10.bool 复杂查询
可以有不同组合：传入的参数为同一类型
- must()：查询必须满足的
- mustNot()：查询相反的
- should()：只要满足就行
@Test
public void testBool() throws UnknownHostException {
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
boolQueryBuilder.must(QueryBuilders.termQuery("age","30"));
boolQueryBuilder.should(QueryBuilders.prefixQuery("content","努"));
queryTemplate(boolQueryBuilder);
}
10.5 指定返回字段
11.高亮查询
高亮配置
/**
* 高亮查询
* .highlighter(highlightBuilder) 用来指定高亮设置
* requireFieldMatch(false) 开启多个字段高亮 [默认只高亮匹配部分]
* field 用来定义高亮字段
* preTags("<span style='color:red'>") 用来指定高亮前缀
* postTags("</span>") 用来指定高亮后缀
*/
@Test
public void testHighlight() throws UnknownHostException {
//===>高亮配置
HighlightBuilder highlightBuilder = new HighlightBuilder();
highlightBuilder.requireFieldMatch(false);//默认只渲染匹配的字段
highlightBuilder.field("name");
highlightBuilder.field("content");
highlightBuilder.preTags("<span style='color:red'>");
highlightBuilder.postTags("</span>");
//创建连接
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
//查询所有文档
SearchResponse searchResponse = transportClient.prepareSearch("ems")//索引
.setTypes("emp")//类型
.setQuery(QueryBuilders.termQuery("content","努力")) //====>
.highlighter(highlightBuilder)//====>
.get();//开始查询
System.out.println("符合条件的总条数:" + searchResponse.getHits().getTotalHits());
System.out.println("最高得分:" + searchResponse.getHits().getMaxScore());
System.out.println("详细记录如下：");
SearchHit[] hits = searchResponse.getHits().getHits();
for (SearchHit h : hits) {
System.out.println("当前索引分数:" + h.getScore());
System.out.println("[字符串形式打印]====>" + h.getSourceAsString());
System.out.println("[map集合形式打印]====>" + h.getSourceAsMap());
}
//关闭连接
transportClient.close();
}
回显高亮数据
高亮数据和原数据是分开显示的，如何将高亮部分存入对象：先将原数据存入对象，再把高亮部分遍历出来替换掉需要高亮显示的部分
@Test
public void testHighlight() throws UnknownHostException {
//用于储存数据:===>
List<Emp> list = new ArrayList<>();
HighlightBuilder highlightBuilder = new HighlightBuilder();
highlightBuilder.requireFieldMatch(false);//默认只渲染匹配的字段
highlightBuilder.field("name");
highlightBuilder.field("content");
highlightBuilder.preTags("<span style='color:red'>");
highlightBuilder.postTags("</span>");
//创建连接
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
//查询所有文档
SearchResponse searchResponse = transportClient.prepareSearch("ems")//索引
.setTypes("emp")//类型
.setQuery(QueryBuilders.termQuery("content", "努力")) //====>
.highlighter(highlightBuilder)//====>
.get();//开始查询
System.out.println("符合条件的总条数:" + searchResponse.getHits().getTotalHits());
System.out.println("最高得分:" + searchResponse.getHits().getMaxScore());
System.out.println("详细记录如下：");
SearchHit[] hits = searchResponse.getHits().getHits();
for (SearchHit h : hits) {
System.out.println("当前索引分数:" + h.getScore());
System.out.println("[字符串形式打印]====>" + h.getSourceAsString());
System.out.println("[map集合形式打印]====>" + h.getSourceAsMap());
//打印高亮部分
System.out.println(h.getHighlightFields());
//原数据
Emp emp = new Emp();
emp.setName((String) h.getSourceAsMap().get("name"));
emp.setAge((Integer) h.getSourceAsMap().get("age"));
emp.setAddress((String) h.getSourceAsMap().get("address"));
//高亮数据
Map<String, HighlightField> highlightFields = h.getHighlightFields();
if (highlightFields.containsKey("name")) {
String nameHigh = highlightFields.get("name").fragments()[0].toString();
//替换
emp.setName(nameHigh);
}
if (highlightFields.containsKey("content")) {
String contentHigh = highlightFields.get("content").fragments()[0].toString();
emp.setContent(contentHigh);
}
list.add(emp);
}
//遍历集合
System.out.println("对象方式显示高亮部分===>:");
list.forEach(emp -> {
System.out.println(emp);
});
//关闭连接
transportClient.close();
}
FilterQuery 过滤查询
过滤查询主要用于查询执行之前对大量数据进行筛选
@Test
public void testFilterQuery() throws UnknownHostException {
//创建连接
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
//查询所有文档
SearchResponse searchResponse = transportClient.prepareSearch("ems")//索引
.setTypes("emp")//类型
.setPostFilter(QueryBuilders.rangeQuery("age").gte(21).lte(30))//===>过滤
.setQuery(QueryBuilders.matchAllQuery()) //===>传入查询的类型
.get();//开始查询
System.out.println("符合条件的总条数:" + searchResponse.getHits().getTotalHits());
System.out.println("最高得分:" + searchResponse.getHits().getMaxScore());
System.out.println("详细记录如下：");
SearchHit[] hits = searchResponse.getHits().getHits();
for (SearchHit h : hits) {
System.out.println("当前索引分数:" + h.getScore());
System.out.println("[字符串形式打印]====>" + h.getSourceAsString());
System.out.println("[map集合形式打印]====>" + h.getSourceAsMap());
}
//关闭连接
transportClient.close();
}
总结
注意setQuery的顺序：
@Test
public void testTotal() throws UnknownHostException {
//1.创建客户端
TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
//es操作
SearchResponse searchResponse = transportClient.prepareSearch("ems1")
.setTypes("emp") //类型
.setFrom(0) //分页
.setSize(20)
.addSort("age", SortOrder.DESC) //排序
.setPostFilter(QueryBuilders.rangeQuery("age").gte(10).lte(30)) //过滤
.setSource(SearchSourceBuilder.searchSource().fetchSource("*", "bir"))//过滤条件
.setQuery(QueryBuilders.multiMatchQuery("小黑最爱框架部分", "name", "content"))//===>查询【有顺序要求：仅高亮在之后】
.highlighter(new HighlightBuilder().field("*").requireFieldMatch(false).preTags("<span style='color:red>").postTags("</span>")) //高亮部分[高亮搜寻字段]
.get();
System.out.println("总条数:" + searchResponse.getHits().getTotalHits());
System.out.println("最大得分:" + searchResponse.getHits().getMaxScore());
SearchHit[] hits = searchResponse.getHits().getHits();
for (SearchHit s : hits) {
System.out.println("原文档部分:" + s.getSourceAsString());
System.out.println("高亮部分:" + s.getHighlightFields());
}
//关闭连接
transportClient.close();
}
SpringData整合ES
SpringBoot和SpringData和ES版本对应关系
搭建环境
改pom
注意如果你使用自动引入依赖，默认使用的springboot版本为最新的，需要将版本改低一点！！！
<!--elasticsearch for springboot-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>
Transport客户端在7版本中不建议使用，在8版本中废除
SpringData也不建议使用Transport，而是使用 HighLevelRESTClient
配置类
两种方式：推荐第二种
如果因为版本关系等问题，第二种方式起不来，可以考虑使用第一种
注意：第一种 和 第二种方式 连接的端口号不一样
方式一：spring-data(2~3.x版本配置) ==> Transport客户端，不建议使用
spring:
data:
elasticsearch:
cluster-nodes: 192.168.77.138:9300
方式二： spring-data(新版本推荐配置) RestHighLevelClient rest客户端 ElasticSearchRespositoy接口
@Configuration
public class RestClientConfig extends AbstractElasticsearchConfiguration {
@Override
@Bean
public RestHighLevelClient elasticsearchClient() {
final ClientConfiguration clientConfiguration = ClientConfiguration.builder()
.connectedTo("192.168.77.138:9200") //===>与kibana客户端类型都是restful分格,都是连接9200端口
.build();
return RestClients.create(clientConfiguration).rest();
}
}
ElasticSearchRespositoy
对一些简单的crud操作，可以使用 ElasticSearchRespositoy 接口
ElasticSearchRespositoy接口提供了一组CRUD的方法
而且自动做到了 对象->JSON，JSON到对象
只提供了基本的方法，想要复杂实现还需要使用 RestHighLevelClient ，例如：高亮，复杂条件查询
通过自定义接口继承ES提供的ElasticsearchRepository接口来实现
继承接口
ElasticsearchRepository ：ES提供的操作CRUD接口
-
第一个参数：指定对象类型 -
第二个参数：对象类型的`主键类型`
/**
* @Author: xj0927
* @Description: ElasticsearchRepository ：ES提供的操作CRUD接口
* 第一个参数：指定对象类型
* 第二个参数：ID类型
*/
public interface EmpRepository extends ElasticsearchRepository<Emp,String> {
}
改造实体类
ES操作相关的实体类，可以只需要业务实体类的某一些字段
@Document: 代表一个文档记录
- indexName: 用来指定索引名称，要求:
ES服务器中之前不能存在此索引名 - type: 用来指定索引类型，SpringBoot一启动就会创建 index 和 type
@Id: 用来将对象中id和ES中_id映射
@Field: 用来指定ES中的字段对应Mapping
- type: 用来指定ES中存储类型
- analyzer: 用来指定使用哪种分词器
/**
* @Document [用在类上]作用: 将Emp的对象映射成ES中一条json格式文档
* indexName : 用来指定这个对象的转为json文档存入那个索引中 要求:==ES服务器中之前不能存在此索引名==
* type : 用来指定在当前这个索引下创建的类型名称
*/
@Document(indexName = "ems", type = "emp")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Emp {
@Id //与ES中_id进行映射
private String id;
/**
* @Description: 用在属性上 代表mapping中一个属性 一个字段
* type:属性 用来指定字段类型 analyzer:指定分词器
*/
@Field(type = FieldType.Text, analyzer = "ik_max_word")
private String name;
@Field(type = FieldType.Integer)
private Integer age;
@Field(type = FieldType.Date)
@JsonFormat(pattern = "yyyy-MM-dd")
private Date bir;
@Field(type = FieldType.Text, analyzer = "ik_max_word")
private String content;
@Field(type = FieldType.Keyword)
private String address;
}
基本使用【重点】
@SpringBootTest
class DemoEsApplicationTests {
@Autowired
EmpRepository empRepository;
/**
* 保存 或 删除
这种方式根据实体类中中配置自动在ES创建索引,类型以及映射
- ID存在，就是更新（`覆盖更新`），如果想要真正更新，应该先查询，后修改，再更新
- ID不存在，就是插入
*/
@Test
public void testSaveOrUpdate(){
Emp emp=new Emp();
emp.setId(UUID.randomUUID().toString().replaceAll("-","").substring(0,7))
.setName("张三")
.setAge(18)
.setAddress("深圳南山区")
.setBir(new Date())
.setContent("法外狂徒，说的就是我!");
System.out.println(emp.toString());
empRepository.save(emp);
}
/**
* 查询所有
*/
@Test
public void testFindAll(){
Iterable<Emp> all = empRepository.findAll();
// 方法重载：
// empRepository.findAll(Sort sort)
// empRepository.findAll(Pageable pageable)
all.forEach(System.out::println);
}
/**
* 查询一个
*/
@Test
public void testFindOne(){
Optional<Emp> byId = empRepository.findById("78f492f");
System.out.println(byId.get());
}
/**
* 根据对象属性删除
*/
@Test
public void testDeleteByEmp(){
Emp emp=new Emp();
emp.setId("78f492f");
//一般是根据对象的ID删除，当不指定ID，根据name删除时:Cannot delete entity with id 'null'.
empRepository.delete(emp);
}
/**
* 根据ID删除
*/
@Test
public void testDeleteById(){
empRepository.deleteById("78f492f");
}
/**
* 删除所有
*/
@Test
public void testDeleteAll(){
empRepository.deleteAll();
}
/**
* 查询、排序
*/
@Test
public void testFindSort(){
Iterable<Emp> emps = empRepository.findAll(Sort.by(Sort.Order.asc("age")));
emps.forEach(System.out::println);
}
/**
* 查询、分页
*/
@Test
public void testFindPage(){
Page<Emp> search = empRepository.search(QueryBuilders.matchAllQuery(), PageRequest.of(0, 3));
search.forEach(System.out::println);
}
}
自定义基本查询
通过 ElasticsearchRepository 接口除了ES提供的api还可以在自定义接口中自定义一些查询的方法
自定定义的方法里面有几个参数，具体看第三栏里面有几个？号
| Keyword | Sample | Elasticsearch Query String |
|---|---|---|
And：同时满足 | findByNameAndPrice | {“bool” : {“must” : [ {“field” : {“name” : “?”}}, {“field” : {“price” : “?”}} ]}} |
Or：满足其一 | findByNameOrPrice | {“bool” : {“should” : [ {“field” : {“name” : “?”}}, {“field” : {“price” : “?”}} ]}} |
Is：据某个字段查询 | findByName | {“bool” : {“must” : {“field” : {“name” : “?”}}}} |
Not：不包含 | findByNameNot | {“bool” : {“must_not” : {“field” : {“name” : “?”}}}} |
Between：某个字段在某个范围之间 | findByPriceBetween | {“bool” : {“must” : {“range” : {“price” : {“from” : ?,“to” : ?,“include_lower” : true,“include_upper” : true}}}}} |
LessThanEqual：<= | findByPriceLessThanEqual | {“bool” : {“must” : {“range” : {“price” : {“from” : null,“to” : ?,“include_lower” : true,“include_upper” : true}}}}} |
GreaterThanEqual：>= | findByPriceGreaterThanEqual | {“bool” : {“must” : {“range” : {“price” : {“from” : ?,“to” : null,“include_lower” : true,“include_upper” : true}}}}} |
Before：…之前 | findByPriceBefore | {“bool” : {“must” : {“range” : {“price” : {“from” : null,“to” : ?,“include_lower” : true,“include_upper” : true}}}}} |
After：…之后 | findByPriceAfter | {“bool” : {“must” : {“range” : {“price” : {“from” : ?,“to” : null,“include_lower” : true,“include_upper” : true}}}}} |
Like：模糊匹配 | findByNameLike | {“bool” : {“must” : {“field” : {“name” : {“query” : “?*”,“analyze_wildcard” : true}}}}} |
StartingWith | findByNameStartingWith | {“bool” : {“must” : {“field” : {“name” : {“query” : “?*”,“analyze_wildcard” : true}}}}} |
EndingWith | findByNameEndingWith | {“bool” : {“must” : {“field” : {“name” : {“query” : “*?”,“analyze_wildcard” : true}}}}} |
Contains/Containing | findByNameContaining | {“bool” : {“must” : {“field” : {“name” : {“query” : “?”,“analyze_wildcard” : true}}}}} |
In | findByNameIn (Collectionnames) | {“bool” : {“must” : {“bool” : {“should” : [ {“field” : {“name” : “?”}}, {“field” : {“name” : “?”}} ]}}}} |
NotIn | findByNameNotIn (Collectionnames) | {“bool” : {“must_not” : {“bool” : {“should” : {“field” : {“name” : “?”}}}}}} |
Near | findByStoreNear | Not Supported Yet ! |
True | indByAvailableTrue | {“bool” : {“must” : {“field” : {“available” : true}}}} |
False | findByAvailableFalse | {“bool” : {“must” : {“field” : {“available” : false}}}} |
OrderBy | findByAvailable TrueOrderByNameDesc | {“sort” : [{ “name” : {“order” : “desc”} }],“bool” : {“must” : {“field” : {“available” : true}}}} |
显示详细信息
举一些例子：
public interface EmpRepository extends ElasticsearchRepository<Emp,String> {
//根据地址查询，address类型为keyword
List<Emp> findEmpByAddress(String address);
//根据Content查询，content类型为text
List<Emp> findEmpByContent(String content);
//和上面一样的效果，写不写Emp都行
List<Emp> findByContent(String spring);
List<Emp> findEmpByNameAndAddress(String name,String addresss);
//年龄范围查询，多少岁之前
List<Emp> findEmpByAgeBefore(Integer age);
//年龄范围查询，多少岁之间
List<Emp> findEmpByAgeBetween(Integer before,Integer after);
//查询名字以namestr开头
List<Emp> findEmpByNameStartingWith(String namestr);
//查询名字以namestr结束
List<Emp> findEmpByNameEndingWith(String namestr);
//查询名字字段是false
List<Emp> findEmpByNameIsFalse();
//?? 和上一个有啥区别
List<Emp> findEmpByNameFalse();
//.......
//.......
//根据名字查询，然后 根据Pageable 参数进行分页
//调用时：PageRequest page = PageRequest.of(0, 2);
List<Emp> findByContent(String name, Pageable pageable);
}
@SpringBootTest
public class DemoESEmpRepository {
@Autowired
EmpRepository empRepository;
@Test
public void testFind(){
List<Emp> list1 = empRepository.findEmpByContent("Spring");
list1.forEach(System.out::println);
System.out.println("----------");
List<Emp> list2 = empRepository.findByContent("Spring");
list2.forEach(System.out::println);
}
/**
* 测试结果为空，不知道为啥
*/
@Test
public void testFind2(){
System.out.println("------测试keyword是否分词-----");
empRepository.findEmpByAddress("北京");
System.out.println("-----------");
empRepository.findEmpByAddress("北");
}
@Test
public void testFind3(){
List<Emp> list = empRepository.findEmpByAgeBefore(10);
list.forEach(System.out::println);
List<Emp> list1 = empRepository.findEmpByAgeBetween(10, 30);
System.out.println(list1);
}
@Test
public void testFind4(){
List<Emp> list = empRepository.findEmpByNameStartingWith("张");
list.forEach(System.out::println);
List<Emp> list1 = empRepository.findEmpByNameEndingWith("黑");
list1.forEach(System.out::println);
}
}
RestHighLevelClient
简单操作
使用：RestHighLevelClient 实现 添加文档、更新文档、删除文档、批量操作
新增、更新、删除、批量 比较简单，一般使用 ElasticSearchRespositoy
@Autowired
RestHighLevelClient restHighLevelClient;
/**
* 测试添加文档索引
*
* @throws IOException
*/
@Test
public void testAddIndex() throws IOException {
//创建索引请求：IndexRequest
IndexRequest indexRequest = new IndexRequest("ems", "emp", "1001");
Emp emp = new Emp();
emp.setName("张三")
.setAge(18)
.setAddress("深圳南山区")
.setBir(new Date())
.setContent("法外狂徒，说的就是我!");
String jsonstring = JSONObject.toJSONString(emp);
System.out.println(jsonstring);
//添加索引文档内容
indexRequest.source(jsonstring, XContentType.JSON);
//执行
IndexResponse index = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);
System.out.println(index.status());
}
/**
* 测试更新：覆盖更新
* @throws IOException
*/
@Test
public void testUpdate() throws IOException {
UpdateRequest updateRequest = new UpdateRequest("ems","emp","1001");
Emp emp = new Emp();
emp.setName("张三").setContent("我是遵纪守法的好孩子啊!!!");
String jsonstring = JSONObject.toJSONString(emp);
updateRequest.doc(jsonstring,XContentType.JSON);
UpdateResponse update = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);
System.out.println(update.status());
}
/**
* 测试删除文档
*
* @throws IOException
*/
@Test
public void testDeleteIndex() throws IOException {
//创建删除请求：DeleteRequest
DeleteRequest deleteRequest = new DeleteRequest("ems", "emp", "_wFek30B3OoLb179U_1P");
//删除
DeleteResponse delete = restHighLevelClient.delete(deleteRequest, RequestOptions.DEFAULT);
System.out.println(delete.status());
}
/**
* 测试批量操作
* @throws IOException
*/
@Test
public void testBatch() throws IOException {
//
BulkRequest bulkRequest=new BulkRequest();
//添加
IndexRequest indexRequest = new IndexRequest("ems","emp","10086");
indexRequest.source(new Emp(),XContentType.JSON);
//删除
DeleteRequest deleteRequest=new DeleteRequest("ems","emp","10088");
//修改
UpdateRequest updateRequest=new UpdateRequest("ems","emp","10086");
updateRequest.doc(new Emp(),XContentType.JSON);
//添加进批量操作
bulkRequest.add(indexRequest);
bulkRequest.add(deleteRequest);
bulkRequest.add(updateRequest);
BulkResponse bulk = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
BulkItemResponse[] items = bulk.getItems();//获取每一条的结果
for (int i = 0; i < items.length; i++) {
System.out.println(items[i].status());
}
}
简单查询
查询所有
/**
* 查询所有
* @throws IOException
*/
@Test
public void testQueryAll() throws IOException {
SearchRequest searchRequest = new SearchRequest("ems");
//创建搜索条件
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//查询所有
searchSourceBuilder.query(QueryBuilders.matchAllQuery());
searchRequest.types("emp").source(searchSourceBuilder);
SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
SearchHit[] hits = searchResponse.getHits().getHits();
for (SearchHit hit : hits) {
System.out.println(hit.getSourceAsString());
}
}
分页查询并排序
@Test
public void testSearchPage() throws IOException {
//查询请求
SearchRequest searchRequest = new SearchRequest();
//查询条件
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
sourceBuilder
.from(0)
.size(2)
.sort("age", SortOrder.ASC)
.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());
}
}
简单条件查询
/**
* 简答条件查询
*
* @throws IOException
*/
@Test
public void testSearchTwo() throws IOException {
//构建搜索请求
SearchRequest searchRequest = new SearchRequest("ems");
//搜索构建对象
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
//执行查询条件===>> 在 content 中找 Spring
//搜索英文单词的话，把英文单词转为小写再查；Spring（查不到） --> spring（能查到）
searchSourceBuilder.query(QueryBuilders.termQuery("content", "spring"))
.from(0)
.size(3)
.postFilter(QueryBuilders.matchAllQuery()) //过滤条件
.sort("age", SortOrder.DESC)
.highlighter(new HighlightBuilder().field("*").requireFieldMatch(false));
//创建搜索请求
searchRequest.types("emp").source(searchSourceBuilder);
SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
System.out.println("符合条件的文档总数: " + searchResponse.getHits().getTotalHits());
System.out.println("符合条件的文档最大得分: " + searchResponse.getHits().getMaxScore());
SearchHit[] hits = searchResponse.getHits().getHits();
for (int i = 0; i < hits.length; i++) {
System.out.println(hits[i].getSourceAsMap());
}
}
复杂对象查询【重点】
1.在content中找关键词：框架
2.排序
3.分页
4.高亮
5.把查询结果（map集合）封装为（实体类对象）
6.提取 查询结果中 的 高亮数据
/**
* 测试复杂对象查询
* @throws ParseException
* @throws IOException
*/
@Test
public void testSearchQuery() throws ParseException, IOException {
List<Emp> emps=new ArrayList<>();
//创建搜索请求
SearchRequest searchRequest = new SearchRequest("ems");
//创建搜索对象
SearchSourceBuilder searchSourceBuilder=new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.termsQuery("content","框架"))
.sort("age",SortOrder.DESC)
.from(0)
.size(10)
.highlighter(new HighlightBuilder()
.field("*")
.requireFieldMatch(false)
.preTags("<span style='color:red'>")
.postTags("</span>"));
searchRequest.types("emp").source(searchSourceBuilder);
//执行搜索
SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
SearchHit[] searchHits = searchResponse.getHits().getHits();
for (SearchHit hit : searchHits) {
System.out.println(hit);
//原始文档 ===自己封装===》 Emp对象
Map<String, Object> sourceAsMap = hit.getSourceAsMap();
Emp emp=new Emp();
emp.setId(hit.getId());
emp.setAge(Integer.valueOf(sourceAsMap.get("age").toString()));
emp.setBir(new SimpleDateFormat("yyyy-MM-dd").parse(sourceAsMap.get("bir").toString()));
emp.setName(sourceAsMap.get("name").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("addresss").fragments()[0].toString());
}
//放入集合
emps.add(emp);
}
emps.forEach(System.out::println);
}
为什么要分开拿原文档和高亮部分：
层级结构：
原来的文档部分：hits -> hits
高亮部分：hits -> highlight
搭建ES集群
相关概念
集群(cluster)
是什么
一个集群就是由一个或多个节点组织在一起，它们共同持有你整个的数据，并一起提供索引和搜索功能。一个集群 由一个唯一的名字标识，这个名字默认就是elasticsearch。这个名字是重要的，因为一个节点只能通过指定某个集群的名字，来加入这个集群。在产品环境中显式地设定这个名字是一个好习惯，但是使用默认值来进行测试/开发也是不错的。
能干嘛
1.单节点压力问题：并发压力、物理资源上限压力
2.数据冗余备份能力
节点(node)
是什么
一个节点是你集群中的一个服务器，作为集群的一部分，它存储你的数据，参与集群的索引和搜索功能。和集群类似，一个节点也是由一个名字来标识的，默认情况下，这个名字是一个随机的漫威漫画角色的名字，这个名字会在启动的时候赋予节点。这个名字对于管理工作来说挺重要的，因为在这个管理过程中，你会去确定网络中的哪些服务器对应于Elasticsearch集群中的哪些节点。
能干嘛
一个节点可以通过配置集群名称的方式来加入一个指定的集群。默认情况下，每个节点都会被安排加入到一个叫 做“elasticsearch”的集群中，这意味着，如果你在你的网络中启动了若干个节点，并假定它们能够相互发现彼此，它们将会自动地形成并加入到一个叫做“elasticsearch”的集群中。
在一个集群里，只要你想，可以拥有任意多个节点。而且，如果当前你的网络中没有运行任何Elasticsearch节点， 这时启动一个节点，会默认创建并加入一个叫做“elasticsearch”的集群。
分片和复制(shards & replicas)
分片是什么
一个索引可以存储超出单个结点硬件限制的大量数据。比如，一个具有10亿文档的索引占据1TB的磁盘空间，而任一节点都没有这样大的磁盘空间;或者单个节点处理搜索请求，响应太慢。为了解决这个问题，**Elasticsearch提供了将索引划分成多份的能力，这些份就叫做分片。**当你创建一个索引的时候，你可以指定你想要的分片的数量。每个分片本身也是一个功能完善并且独立的“索引”，这个“索引”可以被放置 到集群中的任何节点上。
分片之所以重要，主要有两方面的原因:
允许你水平分割/扩展你的内容容量允许你在分片(潜在地，位于多个节点上)之上进行分布式的、并行的操作，进而提高性能/吞吐量 至于一个分片怎样分布，它的文档怎样聚合回搜索请求，是完全由Elasticsearch管理的，对于作为用户的你来说，这些都是透明的。
复制是什么
在一个网络/云的环境里，失败随时都可能发生，在某个分片/节点不知怎么的就处于离线状态，或者由于任何原因 消失了。这种情况下，有一个故障转移机制是非常有用并且是强烈推荐的。为此目的，Elasticsearch允许你创建分片的一份或多份拷贝，这些拷贝叫做复制分片，或者直接叫复制。 复制之所以重要，主要有两方面的原因:
在分片/节点失败的情况下，提供了高可用性。因为这个原因，注意到复制分片从不与原/主要 (original/primary)分片置于同一节点上是非常重要的。 扩展你的搜索量/吞吐量，因为搜索可以在所有的复制上并行运行
总之，每个索引可以被分成多个分片。一个索引也可以被复制0次(意思是没有复制)或多次。一旦复制了，每个索引就有了主分片(作为复制源的原来的分片)和复制分片(主分片的拷贝)之别。分片和复制的数量可以在索引创建的时候指定。在索引创建之后，你可以在任何时候动态地改变复制数量，但是不能改变分片的数量。
默认情况下，Elasticsearch 7 之前ES中的每个索引被分片5个主分片和1个复制，这意味着，如果你的集群中至少有两个节点，你的索引将会有5个主分片和另外5个复制分片(1个完全拷贝)，这样的话每个索引总共就有10个分片。一个 索引的多个分片可以存放在集群中的一台主机上，也可以存放在多台主机上，这取决于你的集群机器数量。主分片和复制分片的具体位置是由ES内在的策略所决定的。
集群架构图
环境搭建
1、将原有ES安装包复制三份
cp -r elasticsearch-6.8.0/ es_node1/
cp -r elasticsearch-6.8.0/ es_node2/
cp -r elasticsearch-6.8.0/ es_node3/
2. 删除复制目录中data目录
由于复制目录之前使用过因此需要在创建集群时将原来数据删除
注意: 如果你是重新安装的ES，这个步骤可以省略
但是如果你之前安装过IK分词器，建议你直接复制，这样就可以省略重新去安装IK分词器
rm -rf es_node1/data
rm -rf es_node2/data
rm -rf es_node3/data
3、调整JVM内存
由于ES启动时比较消耗内存，需要进行调整，你有两种方式可以选择：
- 第一种：调大虚拟机分配的内存
- 第二种：调整ES所占用内存
这里选择第二种
编辑没有文件夹中config目录中jvm.options文件跳转启动内存
vim es_node1/config/jvm.options
vim es_node2/config/jvm.options
vim es_node3/config/jvm.options
分别调整为：[根据个人虚拟机情况调整，我这里虚拟机分配了1G，我有三台ES,所以选择分配300m]
-Xms300m -Xmx300m
4、集群配置
分别修改三个文件夹中config目录中elasticsearch.yml文件
vim es_node1/config/elasticsearch.yml
vim es_node2/config/elasticsearch.yml
vim es_node3/config/elasticsearch.yml
分别修改如下配置:
cluster.name: es #集群名称(集群名称必须一致)
node.name: node1 #节点名称(节点名称不能一致)
network.host: 0.0.0.0 #监听地址(必须开启远程权限,并关闭防火墙)
http.port: 9201 #监听端口(在一台机器时服务端口不能一致)
discovery.zen.ping.unicast.hosts: ["192.168.77.138:9302", "192.168.77.138:9303"] #另外两个节点的ip
gateway.recover_after_nodes: 3 #集群可做master的最小节点数
transport.tcp.port: 9301 #集群TCP端口(在一台机器搭建必须修改)
cluster.name: es #集群名称(集群名称必须一致)
node.name: node1 #节点名称(节点名称不能一致)
network.host: 0.0.0.0 #监听地址(必须开启远程权限,并关闭防火墙)
http.port: 9202 #监听端口(在一台机器时服务端口不能一致)
discovery.zen.ping.unicast.hosts: ["192.168.77.138:9301", "192.168.77.138:9303"] #另外两个节点的ip
gateway.recover_after_nodes: 3 #集群可做master的最小节点数
transport.tcp.port: 9302 #集群TCP端口(在一台机器搭建必须修改)
cluster.name: es #集群名称(集群名称必须一致)
node.name: node1 #节点名称(节点名称不能一致)
network.host: 0.0.0.0 #监听地址(必须开启远程权限,并关闭防火墙)
http.port: 9203 #监听端口(在一台机器时服务端口不能一致)
discovery.zen.ping.unicast.hosts: ["192.168.77.138:9301", "192.168.77.138:9302"] #另外两个节点的ip
gateway.recover_after_nodes: 3 #集群可做master的最小节点数
transport.tcp.port: 9303 #集群TCP端口(在一台机器搭建必须修改)
注意：
- 监听端口是指web页面访问的端口，TCP端口是集群服务器之间通信用的端口
- transport.tcp.port需要在末尾自己添加
5、启动ElasticSearch
切换到非root身份，启动多个es
./es_node1/bin/elasticsearch
./es_node2/bin/elasticsearch
./es_node3/bin/elasticsearch
如果启动时，出现以下情况：
Exception in thread "main" java.nio.file.AccessDeniedException:
.....
解决办法：集群启动BUG解决方案
6、查看节点状态
浏览器分别访问：
http://192.168.77.138:9201/
http://192.168.77.138:9202/
http://192.168.77.138:9203/
如果出现以下数据：
代表集群创建成功！
7、 查看集群健康
如果你想要看集群的整体情况，你可以访问：
http://192.168.77.138:9201/_cat/health?v
解释以下为什么这里的主分片是7，而总分片是14，因为我使用了kibana连接了ElasticSearch，默认会创建两个索引，且索引分片为1，分片副本也为1；同时我自己创建了一个索引：索引分片为5，分片副本为1。所以最终主分片为：5+1+1，全部分片[主分片+副本分片]：5*2+2+2=14，如果你没有用kibana连接ES，也没有自己创建索引，则这里的分片数量为0
8、kiabana 连接 ES集群
如果你之前连接过一台ES集群[为什么说一台也是集群呢？因为ES启动方式就是集群启动，只是集群数量为一台]，其实需要修改的地方都差不多
进入kibana配置文件：
vim kibana-6.8.0-linux-x86_64/configkibana.yml
修改连接ES的地址为集群中的任意一台：
server.host: "192.168.77.138"
elasticsearch.hosts: ["http://192.168.77.138:9201"]
9、SpringBoot 连接ES集群
如果你之前有用SpringBoot连接ES，这里的配置差不多，只是需要将连接地址改为所有的节点地址（防止其中某一台断掉不可用）
package com.elaticsearch.config;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.elasticsearch.client.ClientConfiguration;
import org.springframework.data.elasticsearch.client.RestClients;
import org.springframework.data.elasticsearch.config.AbstractElasticsearchConfiguration;
/**
* @Author: xj0927
* @Description: RestHighLevelClient 客户端配置
* @Date Created in 2020-12-30 14:05
* @Modified By:
*/
@Configuration
public class RestClientConfig extends AbstractElasticsearchConfiguration {
@Override
@Bean
public RestHighLevelClient elasticsearchClient() {
final ClientConfiguration clientConfiguration = ClientConfiguration.builder()
.connectedTo("192.168.77.138:9201","192.168.77.138:9202","192.168.77.138:9203") //===>与kibana客户端类型都是restful分格,都是连接9200端口[这里填写你开放的web端口]
.build();
return RestClients.create(clientConfiguration).rest();
}
}
Head 集群可视化
通过访问http://192.168.77.138:9201/_cat/health?v
我们并不知道每台服务器的具体健康状态如何，这时便可使用我们的head插件，注意该插件并不是官方提供的，是国外的一位大神针对ES集群健康状态开发的
1.安装 nodejs
head 插件需要使用node环境，所以需要先安装node
（1）下载安装包
下载地址：
https://nodejs.org/download/release/v10.15.3/node-v10.15.3-linux-arm64.tar.xz
（2）解压
注意该解压包是以.xz结尾的，需要先解压成.tar结尾的
xz -d node-v10.15.3-linux-arm64.tar.xz
tar -xvf node-v10.15.3-linux-x64.tar
解压完成后，进入bin目录，
./node --version
但此时只能在当前目录下执行，还需要配置环境变量
（3）配置环境变量
# 改名
mv node-v10.15.3-linux-x64 nodejs
# 放入/usr/下
mv nodejs /usr/nodejs
修改配置文件
vim /etc/profile
在末尾添加：
export NODE_HOME=/usr/nodejs
export PATH=$PATH:$JAVA_HOME/bin:$NODE_HOME/bin
使配置文件生效：
source /etc/profile
（4）测试
在任意目录下，查看
node -v
代表 node 安装成功！
2.安装Head
（1）下载安装包
官网地址：
https://codeload.github.com/mobz/elasticsearch-head/zip/master
（2）解压
unzip elasticsearch-head-master.zip
（3）更换阿里源
默认使用的仓库，下载速度比较慢，这里更换国内阿里源，可以提高下载速度
进入elasticsearch-head的目录，
npm config set registry https://registry.npm.taobao.org
（4）下载安装
npm install
（5）启动插件
npm run start
（6）测试
访问：这里localhost要换成你的ip地址
http://192.168.77.138:9100/
在Head中输入ES集群中任意一台节点的访问地址，便可以可视化集群的状态，但这里还不行，前面我们提到Head不是官方提供的，Head和ElasticSearch在不用的域，所以还需要解决跨域访问的问题
（7）解决跨域问题
编写每台ES服务器的elastsearch.yml配置文件开启head插件的访问，在末尾分别添加如下内容：
http.cors.enabled: true
http.cors.allow-origin: "*"
然后重启每台ES服务，便可以访问到集群了
（8）访问Head插件
启动访问head插件 默认端口9100
http://192.168.77.138:9100/
3.集群状态变化演示
这里我们创建主分片为5，副本为1的ems索引（如果不指定，ElasticSearch 7 之前的版本默认为5和1，我们这里用的6.8.0）
可以看到主分片和副本分片分布在不同的节点，同时保证主副分片不在同一节点（保证节点发生故障时可用），
现在我们停掉node1节点：
可以看到集群仍然可用，虽然有些副本失效了，但是还是保证了5个主分片可用（即保证了数据的完整性）
现在我们停掉node2节点：
集群仍然可用，只是集群数量现在只有一台，主分片依然完整。
现在我们重启node2节点：
发现集群慢慢同步了数据，去分担node1节点的压力，此时完整的主副分片都分布在者=这两个节点中，所以健康状态为：green
现在我们重启node1节点：
我们发现分片又重新分布在了不同的节点，健康状态为：green
综合项目实战
后台管理系统
前台高亮搜索
扫一扫
297
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
