ElasticSearch

tech2023-03-02  121

ElasticSearch

一.ElasticSearch相关概念

1.1.ElasticSearch介绍

1.1.1.什么是ES

​ ES是一个分布式的全文搜索引擎,为了解决原生Lucene使用的不足,优化Lucene的调用方式,并实现了高可用的分布式集群的搜索方案,ES的索引库管理支持依然是基于Apache Lucene™的开源搜索引擎。

​ ES也使用Java开发并使用Lucene作为其核心来实现所有索引和搜索的功能,但是它的目的是通过简单的 RESTful API来隐Lucene

​ 的复杂性,从而让全文搜索变得简单。

1.1.2.ES的特点
分布式全文搜索引擎能在分布式项目/集群中使用本身支持集群扩展处理PB级结构化或非结构化数据简单的 RESTful API通信方式支持各种语言的客户端基于Lucene封装,使操作简单
1.1.3.ES和lucene的区别

Lucene:

只支持Java非分布式的,索引目录只能在本地使用非常复杂小项目使用

1.2.ES的相关概念

1.2.1.Near Realtime(NRT)

近实时,两个意思,从写入数据到数据可以被搜索到有一个小延迟(大概1秒);基于es执行搜索和分析可以达到秒级

1.2.2.Index:索引库

包含一堆有相似结构的文档数据,比如可以有一个客户索引,商品分类索引,订单索引,索引有一个名称。一个index包含很多document,一个index就代表了一类类似的或者相同的document。比如说建立一个product index,商品索引,里面可能就存放了所有的商品数据,所有的商品document。

1.2.3.Type:类型

每个索引里都可以有一个或多个type,type是index中的一个逻辑数据分类,一个type下的document,都有相同的field,比如博客系统,有一个索引,可以定义用户数据type,博客数据type,评论数据type。

1.2.4.Document&field

文档,es中的最小数据单元,一个document可以是一条客户数据,一条商品分类数据,一条订单数据,通常用JSON数据结构表示,每个index下的type中,都可以去存储多个document。一个document里面有多个field,每个field就是一个数据字段。

1.2.5.Cluster:集群

包含多个节点,每个节点属于哪个集群是通过一个配置(集群名称,默认是elasticsearch)来决定的,对于中小型应用来说,刚开始一个集群就一个节点很正常

1.2.6.Node:节点

集群中的一个节点,节点也有一个名称(默认是随机分配的),节点名称很重要(在执行运维管理操作的时候),默认节点会去加入一个名称为"elasticsearch"的集群,如果直接启动一堆节点,那么它们会自动组成一个elasticsearch集群,当然一个节点也可以组成一个elasticsearch集群

1.2.7.shard(分片)

单台机器无法存储大量数据,es可以将一个索引中的数据切分为多个shard,分布在多台服务器上存储。有了shard就可以横向扩展,存储更多数据,让搜索和分析等操作分布到多台服务器上去执行,提升吞吐量和性能。每个shard都是一个lucene index。

1.2.8.replica(复制品)

任何一个服务器随时可能故障或宕机,此时shard可能就会丢失,因此可以为每个shard创建多个replica副本。replica可以在shard故障时提供备用服务,保证数据不丢失,多个replica还可以提升搜索操作的吞吐量和性能。primary shard(建立索引时一次设置,不能修改,默认5个),replica shard(随时修改数量,默认1个),默认每个索引10个shard,5个primary shard,5个replica shard,最小的高可用配置,是2台服务器。

1.2.9.集群原理图

二.ElasticSearch的安装

2.1.ElasticSearch安装

2.1.1.下载

​ https://www.elastic.co/downloads/elasticsearch

2.1.2.安装

​ 解压即可

2.1.3.测试

访问:http://localhost:9200

2.2.可视化工具安装

2.2.1.Kibana5安装
1.下载

​ https://www.elastic.co/downloads/kibana

2.配置

​ 解压并编辑config/kibana.yml,设置elasticsearch.url的值为已启动的ES

3.启动Kibana5

​ bin\kibana.bat

4.默认访问地址

​ http://localhost:5601

2.2.2.elasticsearch-header
1.下载

https://github.com/mobz/elasticsearch-head/releases

2.安装

npm install

3.运行

npm run start

4.配置跨域

修改 elasticsearch/config/elasticsearch.yml

http.cors.enabled: truehttp.cors.allow-origin: “*”

2.3.分词器安装

2.3.1.什么是分词
2.3.2.什么是分词器
2.3.3.安装IK分词器

ES默认对英文文本的分词器支持较好,但和lucene一样,如果需要对中文进行全文检索,那么需要使用中文分词器,同lucene一样,在使用中文全文检索前,需要集成IK分词器。

下载IK分词器

​ ES的IK分词器插件源码地址:https://github.com/medcl/elasticsearch-analysis-ik

解压elasticsearch-analysis-ik-5.2.2.zip文件

​ 并将其内容放置于ES根目录/plugins/ik

IK分词器配置

IK分词测试

POST _analyze { "analyzer":"ik_smart", "text":"中国驻洛杉矶领事馆遭亚裔男子枪击 嫌犯已自首" }

IK分词器指定:ik_smart ; ik_max_word

三.RestFull风格

3.1.基本定义

3.1.1.什么是Restfull

​ Restful是一种面向资源的架构风格,可以简单理解为:使用URL定位资源,用HTTP动(GET,POST,DELETE,PUT)描述操作。

3.1.2.Restful的好处
透明性,暴露资源存在。充分利用 HTTP 协议本身语义。(GET POST DELETE POST PUT)无状态,这点非常重要。在调用一个接口(访问、操作资源)的时候,可以不用考虑上下文,不用考虑当前状态,极大的降低了复杂度。
3.1.3.Restfull的特点
资源(URL)使用名词表示使用http动词来描述操作

3.2.案例

3.2.1.获取资源
GET /user/1 => 获取id为1的用户GET /users => 获取用户列表
3.2.2.添加数据

PUT /user => 添加用户

{“id”:“1”,“username”:“zs”}

3.2.4.修改

POST /user

{“id”:“1”,“username”:“zs”}

3.2.3.删除资源
DELELE /user/1 => 删除id为1的用户

四.ElasticSearch基础

4.1.索引库CRUD

4.1.1增加索引库
PUT shopping { "settings":{ "number_of_shards":5, "number_of_replicas":1 } }
4.1.2查询索引库
GET _cat/indices?v

查看指定索引库

GET _cat/indices/aigou

4.1.3.删除索引库
DELETE 名字
4.1.4.修改索引库
删除再添加

4.2.文档的CRUD

4.2.1.文档概念
ESMysql_index(索引库)数据库_type(文档类型)表_document(文档对象)一行数据_id(文档ID)主键IDfield(字段)列

其他

_source(文档原始数据-就是保存在ES中的真实数据)_all(所有字段的连接字符串)metadata(文档元数据-出去文档真实数据意外的其他数据)
4.2.2.添加文档

语法

PUT 索引库/文档类型/文档id { 文档原始数据 }

案例:

PUT crm/user/11 { "id":11, "username":"zs" }

解释:添加id为11的用户 , 索引库为 crm,类型为 User

注意:如果不指定文档的id,ES会自动生成文档id

4.2.3.获取文档

a.获取指定文档

GET 索引库/类型/文档ID

b.指定返回的列

GET /itsource/employee/123?_source=fullName,email
4.2.4.修改文档
a.整体修改
PUT {index}/{type}/{id} { 修改后的内容 }

ps: 全量修改的语法跟添加文档语法一样,如果文档已经存在就是添加,否则就是修改,

文档修改过程:1.标记删除旧文档,2.添加新文档

b.局部修改
POST itsource/employee/123/_update { "doc":{ "email" : "nixianhua@itsource.cn", "salary": 1000 } }

ps:文档修改过程: 1.检索旧文档 , 2.修改文档 ,3.标记删除旧文档 , 4.添加新文档

4.2.5.删除文档
DELETE {index}/{type}/{id}

五.文档的查询

5.1.常用查询

5.1.1.查询所有
GET _search
5.1.2.查询指定索引库
GET crm/_search
5.1.3.查询指定类型
GET crm/user/_search
5.1.4.查询指定文档
GET crm/user/11
5.1.5.分页查询
&size=2&from=2 size: 每页条数form:从多少条数据开始查
5.1.6.字符串查询

条件查询+分页+排序

GET crm/user/_search?q=age:17&size=2&from=2&sort=id:desc&_source=id,username

字符串查询(query string)其实就是在url后面以字符串的方式拼接各种查询条件,这种方式不推荐,因为条件过多,拼接起来比较麻烦

5.1.7.批量查询

批量查询很重要,对相比单个查询来说,批量查询性能更高。

a.不同索引库查询
GET _mget { "docs" : [ { "_index" : "itsource", "_type" : "blog", "_id" : 2 }, { "_index" : "itsource", "_type" : "employee", "_id" : 1, "_source": "email,age" } ] }
b.同索引库同类型 - 推荐
GET itsource/blog/_mget { "ids" : [ "2", "1" ] }

六.DSL查询与DSL过滤

6.1.基本概念

6.1.1.基本概念

DSL过滤语句和DSL查询语句非常相似,但是它们的使用目的却不同:DSL过滤查询文档的方式更像是对于我的条件"有"或者"没有"(等于 ;不等于),而DSL查询语句则像是"有多像"(模糊查询)。

6.1.2.查询与过滤的区别

DSL过滤和DSL查询在性能上的区别:

过滤结果可以缓存并应用到后续请求。-> 精确过滤后的结果拿去模糊查询性能高查询语句同时匹配文档,计算相关性,所以更耗时,且不缓存。过滤语句可有效地配合查询语句完成文档过滤。

总结:需要模糊查询的使用DSL查询 ,需要精确查询的使用DSL过滤,在开发中组合使用(组合查询) -> 关键字查询使用DSL查询,其他的都是用DSL过滤。

6.2.综合案例

6.2.1.语法介绍
GET crm/user/_search { "query": { "bool": { "must": [ {"match": {"description": "search" }} ], "filter": { "term": {"tags": "lucene"} } } }, "from": 20, "size": 10, "_source": ["fullName", "age", "email"], "sort": [{"join_date": "desc"},{"age": "asc"}] }

解释:

query : 查询

bool : 组合查询 , 包含了 DSL查询和DSL过滤

must : 必须匹配 :与(must) 或(should) 非(must_not)

match:分词匹配查询,会对查询条件分词 , multi_match :多字段匹配

filter: 过滤条件

term:词元查询,不会对查询条件分词

from,size :分页

_source :查询结果中需要哪些列

sort:排序

6.2.2综合案例

组合搜索bool可以组合多个查询条件为一个查询对象,名称(name)中有 “娃娃” 的商品 ,价格(minPrice)在 10000- 20000之间,品牌id为 14,按照销量(saleCount)倒排序,查询第 1 页,每页10 条 ,查询结果中只需要 :id,name,minPrice,brandId

GET aigou/product/_search { "query":{ "bool": { "must": [{ "match": { "name": "春季" } }], "filter": [ { "range":{ //范围查询 "minPrice":{ "gte":10000, "lte":20000 } } }, { "term": { //词元查询 "brandId": 14 } } ] } }, "from": 1, "size": 10, "_source": ["id", "name", "minPrice","brandId"], "sort": [{ "saleCount": "desc" }] }

ps:其他查询方式

term:单词/词元查询match : 分词查询(模糊匹配)multi_match :多字段匹配range:范围查询exists :存在missing : 不存在prefix:前缀匹配wildcard:通配符匹配 ,使用*代表0~N个,使用?代表1个。

七.文档的映射

7.1.基本概念

7.1.1.什么是文档映射

​ ES的文档映射(mapping)机制用于进行字段类型确认,将每个字段匹配为一种确定的数据类型。

Mysql建表过程:创建数据库 -> 创建表(指定字段类型) -> crud数据ES创建索引过程:创建索引库 -> 文档类型映射 -> crud文档映射与分词 : 为了方便字段的检索,我么会对某些存储在ES中的字段进行分词,但是有些字段类型可以分词,有些字段类型不可以分词,所以对于字段的类型需要我们自己去指定。
7.1.2.默认的字段类型

查看索引类型的映射配置:GET {indexName}/_mapping/{typeName}

a.基本字段类型

字符串

text(分词), keyword(不分词) ,StringField(不分词文本),TextFiled(要分词文本) ,text默认为全文文本,keyword默认为非全文文本

数字(long,integer,short,double,float)

日期date

逻辑boolean

b.复杂字段类型
对象类型:object数组类型:array地理位置:geo_point,geo_shape
c.默认映射

ES在没有配置Mapping的情况下新增文档,ES会尝试对字段类型进行猜测,并动态生成字段和类型的映射关系。

JSON typeField typeBoolean: true or false“boolean”Whole number: 123“long”Floating point: 123.45“double”String, valid date:“2014-09-15”“date”String: “foo bar”“string”
7.1.3.映射规则

字段映射的常用属性配置列表 - 即给某个字段执行类的时候可以指定以下属性

属性名解释type字段的类型:基本数据类型,integer,long,date,boolean,keyword,text…enable是否启用:默认为true。 false:不能索引、不能搜索过滤。boost权重提升倍数:用于查询时加权计算最终的得分,比如标题中搜索到的内容比简介中搜索到的内容跟重要,那么可以提升index索引模式:analyzed (索引并分词,text默认模式), not_analyzed (索引不分词,keyword默认模式),no(不索引)analyzer索引分词器:索引创建时使用的分词器,如ik_smart,ik_max_word,standardsearch_analyzer搜索分词器:搜索该字段的值时,传入的查询内容的分词器。fields多字段索引:当对该字段需要使用多种索引模式时使用。如:城市搜索New York"city": "city":{ "type": "text", "analyzer": "ik_smart", "fields": { "raw": { "type": "keyword" } } }

解释:相当于给 city取了一个别名 city.raw,city的类型为text , city.raw的类型为 keyword 搜索 city分词 ; 搜索city.raw 不分词那么以后搜索过滤和排序就可以使用city.raw字段名

7.2.添加映射

注意:如果索引库已经有数据了,就不能再添加映射了

7.2.1.创建新的索引库
put aigou
7.2.2.单类型创建映射
put aigou/goods/_mapping { "goods": { "properties": { "id": { "type": "long" }, "name": { "type": "text", "analyzer": "ik_smart", "search_analyzer": "ik_smart" } } } }

解释:给aigou索引库中的是goods类型创建映射 ,id指定为long类型 , name指定为text类型(要分词),analyzer分词使用ik,查询分词器也使用ik

7.2.3.多类型创建映射
PUT aigou { "mappings": { "user": { "properties": { "id": { "type": "integer" }, "info": { "type": "text", "analyzer": "ik_smart", "search_analyzer": "ik_smart" } } }, "dept": { "properties": { "id": { "type": "integer" }, ....更多字段映射配置 } } } }

解释:同时给user和dept创建文档映射

7.3.数组/对象映射

基本类型字段映射非常简单,直接配置对应的类型即可,但是数组和对象如何指定类型呢?

7.3.1.对象映射
{ "id" : 1, "girl" : { "name" : "王小花", "age" : 22 } }

文档映射

{ "properties": { "id": {"type": "long"}, "girl": { "properties":{ "name": {"type": "keyword"}, "age": {"type": "integer"} } } } }
7.3.2.数组映射
{ "id" : 1, "hobby" : ["王小花","林志玲"] }

文档映射

{ "properties": { "id": {"type": "long"}, "hobby": {"type": "keyword"} } }

解释:数组的映射只需要映射一个元素即可,因为数组中的元素类型是一样的。

7.3.3.对象数组
{ "id" : 1, "girl":[{"name":"林志玲","age":32},{"name":"赵丽颖","age":22}] }

文档映射

"properties": { "id": { "type": "long" }, "girl": { "properties": { "age": { "type": "long" }, "name": { "type": "text" } } } }

7.4.全局映射

索引库中多个类型(表)的字段是有相同的映射,如所有的ID都可以指定为integer类型,基于这种思想,我们可以做全局映射,让所有的文档都使用全局文档映射。全局映射可以通过动态模板和默认设置两种方式实现。

7.4.1.默认方式:default

索引下所有的类型映射配置会继承_default_的配置,如:

PUT {indexName} { "mappings": { "_default_": { "_all": { "enabled": false } }, "user": {}, "dept": { "_all": { "enabled": true } } }

关闭默认的 _all ,dept自定义开启 all

7.4.2.动态模板

dynamic_templates

PUT _template/global_template //创建名为global_template的模板 { "template": "*", //匹配所有索引库 "settings": { "number_of_shards": 1 }, //匹配到的索引库只创建1个主分片 "mappings": { "_default_": { "_all": { "enabled": false //关闭所有类型的_all字段 }, "dynamic_templates": [ { "string_as_text": { "match_mapping_type": "string",//匹配类型string "match": "*_text", //匹配字段名字以_text结尾 "mapping": { "type": "text",//将类型为string的字段映射为text类型 "analyzer": "ik_max_word", "search_analyzer": "ik_max_word", "fields": { "raw": { "type": "keyword", "ignore_above": 256 } } } } }, { "string_as_keyword": { "match_mapping_type": "string",//匹配类型string "mapping": { "type": "keyword"//将类型为string的字段映射为keyword类型 } } } ] } }}

PS : 映射方式优先级 (低 -> 高):默认 -> 全局 -> 自定义

7.5.最佳实践

1.建索引库
2.全局映射
3.自定义映射
4.Java-API做CRUD

八.ElasticSearch集群

8.1.集群相关概念

8.1.1.为什么要集群
单节点故障支持高并发海量数据存储
8.1.2.ES节点类型

默认情况下,elasticsearch集群中每个节点都有成为主节点的资格,也都存储数据,还可以提供查询服务。在生产环境下,如果不修改elasticsearch节点的角色信息,在高数据量,高并发的场景下集群容易出现脑裂等问题。这些功能是由两个属性控制的。node.master 和 node.data 默认情况下这两个属性的值都是true。

配置值解释node.mastertrue是否是主节点node.datatrue是否存储数据

主节点master

node.master=true,代表该节点有成为主资格,主节点的主要职责是和集群操作相关的内容,如创建或删除索引,跟踪哪些节点是群集的一部分,并决定哪些分片分配给相关的节点。一般会把主节点和数据节点分开,node.master=true , node.data=false

数据节点data

node.data=true,数据节点主要是存储索引数据的节点,主要对文档进行增删改查操作,聚合操作等,数据节点对CPU,IO,内存要求较高,优化节点的时候需要做状态监控,资源不够时要做节点扩充。配置:mode.master=false,mode.data=true

负载均衡节点client

当主节点和数据节点配置都设置为false的时候,该节点只能处理路由请求,处理搜索,分发索引操作等,从本质上来说该客户节点表现为智能负载平衡器。配置:mode.master=false,mode.data=false

最佳实践

​ 在一个生产集群中我们可以对这些节点的职责进行划分,建议集群中设置3台以上的节点作为master节点,这些节点只负责成为主节点,维护整个集群的状态。再根据数据量设置一批data节点,这些节点只负责存储数据,后期提供建立索引和查询索引的服务,这样的话如果用户请求比较频繁,这些节点的压力也会比较大,所以在集群中建议再设置一批client节点(node.master: false node.data: false),这些节点只负责处理用户请求,实现请求转发,负载均衡等功能。

8.2.ES的集群理解

8.2.1.shard&replica机制

index包含多个shard,一个shard是最小工作单元,存储部分数据,完整的建立索引和处理索引的能力

primary shard不能和自己的replica shard放在同一个节点上(否则节点宕机,primary shard和副本都丢失,起不到容错的作用),但是可以和其他primary shard的replica shard放在同一个节点上

增减节点时,shard会自动在nodes中负载均衡

primary shard和replica shard,每个document肯定只存在于某一个primary shard以及其对应的replica shard中,不可能存在于多个primary shard

replica shard是primary shard的副本,负责容错,以及承担读请求负载 - 读写分离

primary shard的数量在创建索引的时候就固定了,replica shard的数量可以随时修改

primary shard的默认数量是5,replica默认是1,默认有10个shard,5个primary shard,5个replica shard

8.2.2.图解Shard分配
a.单node环境下创建index

​ 单node环境下,创建一个index,有3个primary shard,3个replica shard

这个时候,只会将3个primary shard分配到仅有的一个node上去,另外3个replica shard是无法分配的集群status是yellow集群可以正常工作,但是一旦出现节点宕机,数据全部丢失,而且集群不可用,无法承接任何请求
b.两个node环境下创建index

​ 2个node环境下,创建一个index, 3个primary shard,3个replica shard

c.扩容极限,提升容错

​ 如何让性能达到更优?

每个Node更少的Shard,每个Shard资源跟充沛,性能更高扩容极限:6个shard(3 primary,3 replica),最多扩容到6台机器,每个shard可以占用单台服务器的所有资源,性能最好超出扩容极限,动态修改replica数量,9个shard(3primary,6 replica),扩容到9台机器,比3台机器时,拥有3倍的读吞吐量
8.2.3.容错机制-Master选举

master node宕机,自动进行master选举, - Red

当某个PrimaryShard (主分片)宕机,这个PrimaryShard的某个ReplicShard(备分片)会通过选举成为PrimaryShard。

Replica容错:将replica提升为新的primary shard,- yellow

新的主分片选举成功后,那么保证了主分片的完整性,但是少了一个备分片,所以状态变成了黄色

重启宕机节点:会生成新的ReplicShard,如果宕机前有数据,会像恢复之前的数据,然后从PrimaryShard中拷贝新的数据,这样做的好处是:1.恢复性能好 , 2.可以避免数据同步延迟造成的数据丢失问题(在宕机的一瞬间,有些数据还没同步到ReplicShard,可能会导致数据丢失)

8.3.集群搭建

8.3.1.环境准备

真实环境

NodeNameWeb端口,客户端端口node-1172.168.1.1:9200 172.168.1.1:9300node-2172.168.1.2:9200 172.168.1.2:9300node-3172.168.1.3:9200 172.168.1.3:9300

模拟环境

NodeNameWeb端口,客户端端口node-1127.0.0.1:9201 127.0.0.1:9301node-2127.0.0.1:9202 127.0.0.1:9302node-3127.0.0.1:9203 127.0.0.1:9303

注意:需要准备三个ES(拷贝),然后删除data目录 , 如果电脑内存不够,可以把jvm.properties中的内存设置改小

8.3.2.配置说明
- cluster.name 集群名,自定义集群名,默认为elasticsearch,建议修改,因为低版本多播模式下同一网段下相同集群名会自动加入同一集群,如生产环境这样易造成数据运维紊乱。 - node.name 节点名,同一集群下要求每个节点的节点名不一致,起到区分节点和辨认节点作用 - node.master 是否为主节点,选项为true或false,当为true时在集群启动时该节点为主节点,在宕机或任务挂掉之后会选举新的主节点,恢复后该节点依然为主节点 - node.data 是否处理数据,选项为true或false。负责数据的相关操作 - path.data 默认数据路径,可用逗号分隔多个路径 - path.logs 默认日志路径 - bootstrap.mlockall 内存锁,选项为true或false,用来确保用户在es-jvm中设置的ES_HEAP_SIZE参数内存可以使用一半以上而又不溢出 - network.host 对外暴露的host,0.0.0.0时暴露给外网 - http.port 对外访问的端口号,默认为9200,所以外界访问该节点一般为http://ip:9200/ - transport.tcp.port 集群间通信的端口号,默认为9300 - discovery.zen.ping.unicast.hosts 集群的ip集合,可指定端口,默认为9300,如 ["192.168.1.101","192.168.1.102"] - discovery.zen.minimum_master_nodes 最少的主节点个数,为了防止脑裂,最好设置为(总结点数/2 + 1)个 - discovery.zen.ping_timeout 主节点选举超时时间设置 - gateway.recover_after_nodes 值为n,网关控制在n个节点启动之后才恢复整个集群 - node.max_local_storage_nodes 值为n,一个系统中最多启用节点个数为n - action.destructive_requires_name 选项为true或false,删除indices是否需要现实名字
8.3.3.修改ES配置
Node1-配置 # 统一的集群名 cluster.name: my-ealsticsearch # 当前节点名 node.name: node-1 # 对外暴露端口使外网访问 network.host: 127.0.0.1 # 对外暴露端口 http.port: 9201 #集群间通讯端口号 transport.tcp.port: 9301 #集群的ip集合,可指定端口,默认为9300 discovery.zen.ping.unicast.hosts: ["127.0.0.1:9301","127.0.0.1:9302","127.0.0.1:9303"] Node2-配置 # 统一的集群名 cluster.name: my-ealsticsearch # 当前节点名 node.name: node-2 # 对外暴露端口使外网访问 network.host: 127.0.0.1 # 对外暴露端口 http.port: 9202 #集群间通讯端口号 transport.tcp.port: 9302 #集群的ip集合,可指定端口,默认为9300 discovery.zen.ping.unicast.hosts: ["127.0.0.1:9301","127.0.0.1:9302","127.0.0.1:9303"] Node3-配置 # 统一的集群名 cluster.name: my-ealsticsearch # 当前节点名 node.name: node-3 # 对外暴露端口使外网访问 network.host: 127.0.0.1 # 对外暴露端口 http.port: 9203 #集群间通讯端口号 transport.tcp.port: 9303 #集群的ip集合,可指定端口,默认为9300 discovery.zen.ping.unicast.hosts: ["127.0.0.1:9301","127.0.0.1:9302","127.0.0.1:9303"]

分别启动三个ES节点 , 访问:http://127.0.0.1:9201/

8.4连接集群

8.4.1.修改kibana配置
elasticsearch.url: "http://localhost:9201"

连接其中一个节点自然能连接上整个集群 , 然后启动Kibana

8.4.2.集群查看命令

创建索引

PUT shopping { "settings":{ "number_of_shards":5, "number_of_replicas":1 } }

GET _cat/nodes?v :查看Node

GET _cat/indices?v : 查看索引库

九.JavaApi操作ES

9.1.集成ES

9.1.1.导入依赖
<dependency> <groupId>org.elasticsearch.client</groupId> <artifactId>transport</artifactId> <version>5.2.2</version> </dependency> <dependency> <groupId>org.apache.logging.log4j</groupId> <artifactId>log4j-api</artifactId> <version>2.7</version> </dependency> <dependency> <groupId>org.apache.logging.log4j</groupId> <artifactId>log4j-core</artifactId> <version>2.7</version> </dependency>
9.1.2.连接ES

编写工具

public class ESClientUtil { public static TransportClient getClient(){ Settings settings = Settings.builder() .put("cluster.name","my-ealsticsearch") .put("client.transport.sniff", true).build(); TransportClient client = null; try { client = new PreBuiltTransportClient(settings) .addTransportAddress( new InetSocketTransportAddress(InetAddress.getByName("127.0.0.1"), 9303)); } catch (UnknownHostException e) { e.printStackTrace(); } return client; } }

9.2.文档CRUD

9.2.1.添加文档
@Test public void testAdd() { //获取客户端对象 TransportClient client = ESClientUtil.getClient(); //创建索引 IndexRequestBuilder indexRequestBuilder = client.prepareIndex("shopping", "user", "1"); Map<String,Object> data = new HashMap<>(); data.put("id",1); data.put("username","zs"); data.put("age",11); //获取结果 IndexResponse indexResponse = indexRequestBuilder.setSource(data).get(); System.out.println(indexResponse); client.close(); }
9.2.2.获取文档
GetResponse response = client.prepareGet("crm", "vip", "1").get();
9.2.3.更新文档
@Test public void testUpdate(){ //获取客户端对象 TransportClient client = ESClientUtil.getClient(); //修改索引 UpdateRequestBuilder updateRequestBuilder = client.prepareUpdate("shopping", "user", "1"); Map<String,Object> data = new HashMap<>(); data.put("id",1); data.put("username","zs"); data.put("age",11); //获取结果设置修改内容 UpdateResponse updateResponse = updateRequestBuilder.setDoc(data).get(); System.out.println(updateResponse); client.close(); }
9.2.4.删除文档
@Test public void testDelete(){ //获取客户端对象 TransportClient client = ESClientUtil.getClient(); DeleteRequestBuilder deleteRequestBuilder = client.prepareDelete("shopping", "user", "1"); DeleteResponse deleteResponse = deleteRequestBuilder.get(); System.out.println(deleteResponse); client.close(); }
9.2.5.批量操作
@Test public void testBuilkAdd(){ //获取客户端对象 TransportClient client = ESClientUtil.getClient(); BulkRequestBuilder bulkRequestBuilder = client.prepareBulk(); Map<String,Object> data1 = new HashMap<>(); data1.put("id",11); data1.put("username","zs"); data1.put("age",11); bulkRequestBuilder.add(client.prepareIndex("shopping", "user", "11").setSource(data1)); Map<String,Object> data2 = new HashMap<>(); data2.put("id",22); data2.put("username","zs"); data2.put("age",11); bulkRequestBuilder.add(client.prepareIndex("shopping", "user", "11").setSource(data2)); BulkResponse bulkItemResponses = bulkRequestBuilder.get(); Iterator<BulkItemResponse> iterator = bulkItemResponses.iterator(); while(iterator.hasNext()){ BulkItemResponse next = iterator.next(); System.out.println(next.getResponse()); } client.close(); }

9.3.查询

@Test public void testSearch(){ //获取客户端对象 TransportClient client = ESClientUtil.getClient(); SearchRequestBuilder searchRequestBuilder = client.prepareSearch("shopping"); searchRequestBuilder.setTypes("user"); searchRequestBuilder.setFrom(0); searchRequestBuilder.setSize(10); searchRequestBuilder.addSort("age", SortOrder.ASC); //查询条件 BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery(); List<QueryBuilder> must = boolQueryBuilder.must(); must.add(QueryBuilders.matchQuery("username" , "zs")); List<QueryBuilder> filter = boolQueryBuilder.filter(); filter.add(QueryBuilders.rangeQuery("age").lte(20).gte(10)); filter.add(QueryBuilders.termQuery("id",11)); searchRequestBuilder.setQuery(boolQueryBuilder); SearchResponse searchResponse = searchRequestBuilder.get(); SearchHits hits = searchResponse.getHits(); System.out.println("条数:"+hits.getTotalHits()); for (SearchHit hit : hits.getHits()) { System.out.println(hit.getSource()); } client.close(); }
最新回复(0)