发布时间:2023-05-03 16:00
1、ElasticSearch 概述
The Elastic Stack, 包括 Elasticsearch、Kibana、Beats 和 Logstash(也称为 ELK Stack)。能够安全可靠地获取任何来源、任何格式的数据,然后实时地对数据进行搜索、分析和可视化。Elaticsearch,简称为 ES,ES 是一个开源的高扩展的分布式全文搜索引擎,是整个 Elastic Stack 技术栈的核心。它可以近乎实时的存储、检索数据;本身扩展性很好,可以扩展到上百台服务器,处理 PB 级别的数据。
Elasticsearch 的官方地址:https://www.elastic.co/cn/
直接前往官网当中进行下载,下载完成之后直接进行解压缩即可,解压后,进入 bin 文件目录,点击 elasticsearch.bat 文件启动 ES 服务,解压后直接对9200端口进行访问验证。
2、ElasticSearch之HTTP 操作
2.1、索引操作
2.1.1、新增索引
对比关系型数据库,创建索引就等同于创建数据库,在 Postman 中,向 ES 服务器发 PUT 请求:http://localhost:9200/user
2.1.2、查看所有索引
在 Postman 中,向 ES 服务器发 GET 请求 :localhost:9200/_cat/indices?v
2.1.3、查看单个索引
查看索引向 ES 服务器发送的请求路径和创建索引是一致的。但是 HTTP 方法不一致,改为GET请求
2.1.4、删除索引
改为DELETE请求
2.2、文档操作
2.2.1、创建文档
这里的文档可以类比为关系型数据库中的表数据,添加的数据格式为 JSON 格式
在 Postman 中,向 ES 服务器发 POST 请求 :http://localhost:9200/user/_doc
但是这里返回的数据当中的id是es生成的,那我们要使用自己定义的id又如何设置呢?可以在创建时指定,在最后给定id值,如下的1
2.2.2、查看文档
查看文档时,需要指明文档的唯一性标识,类似于 MySQL 中数据的主键查询,在 Postman 中,向 ES 服务器发 GET 请求 :http://localhost:9200/user/_doc/1
2.2.3、修改文档
输入相同的 URL 地址请求,如果请求体变化,会将原有的数据内容覆盖在 Postman 中,向 ES 服务器发 POST 请求,而当我们发出PUT请求回对所有数据进行覆盖
2.2.4、修改字段
修改数据时,也可以只修改某一给条数据的局部信息
2.2.5、删除文档
删除一个文档不会立即从磁盘上移除,它只是被标记成已删除(逻辑删除)。在 Postman 中,向 ES 服务器发 DELETE 请求
2.3、高级查询
2.3.1、条件查询文档
通过get请求http://localhost:9200/user/_search,通过body体进行查询
{
\"query\":{
\"match\":{
\"sex\":\"男\"
}
}
}
并且我们可以进行设置from(起始位置)和size(每页条数)进行设置分页查询,_source(查指定字段)、sort(根据指定字段排序)
2.3.2、范围查询
range 查询找出那些落在指定区间内的数字或者时间。range 查询允许以下字符
操作符 | 说明 |
---|---|
gt | 大于> |
gte | 大于等于>= |
lt | 小于< |
lte | 小于等于<= |
如下对age进行范围查询
3、ElasticSearch之Java API操作
首先我们创建一个maven项目,之后我们导入es所需要的依赖。
<dependencies>
<dependency>
<groupId>org.elasticsearchgroupId>
<artifactId>elasticsearchartifactId>
<version>7.15.0version>
dependency>
<dependency>
<groupId>org.elasticsearch.clientgroupId>
<artifactId>elasticsearch-rest-high-level-clientartifactId>
<version>7.15.0version>
dependency>
<dependency>
<groupId>org.apache.logging.log4jgroupId>
<artifactId>log4j-apiartifactId>
<version>2.8.2version>
dependency>
<dependency>
<groupId>org.apache.logging.log4jgroupId>
<artifactId>log4j-coreartifactId>
<version>2.8.2version>
dependency>
<dependency>
<groupId>com.fasterxml.jackson.coregroupId>
<artifactId>jackson-databindartifactId>
<version>2.9.9version>
dependency>
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.12version>
dependency>
dependencies>
3.1、创建索引
public static void main(String[] args) throws Exception {
// 创建客户端
RestHighLevelClient client = new RestHighLevelClient(
RestClient.builder(new HttpHost(\"localhost\",9200,\"http\"))
);
// 创建索引
CreateIndexRequest request = new CreateIndexRequest(\"order\");
CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
boolean isAcknowledged = response.isAcknowledged();
System.out.println(isAcknowledged);
// 关闭
client.close();
}
报错 ElasticsearchStatusException[Elasticsearch exception [type=invalid_index_name_exception, reason=Invalid index name [esIndex], must be lowercase]] 这个报错表示索引需使用小写,改为小写即可。
报错 java.lang.ClassNotFoundException: org.elasticsearch.common.CheckedConsumer 这个是因为es的版本不对,将对应的版本以及clinent版本调整为一致即可。
3.2、查看索引
// 创建客户端
RestHighLevelClient client = new RestHighLevelClient(
RestClient.builder(new HttpHost(\"localhost\",9200,\"http\"))
);
// 查看索引
GetIndexRequest request = new GetIndexRequest(\"order\");
GetIndexResponse response = client.indices().get(request, RequestOptions.DEFAULT);
System.out.println(response.getAliases());
System.out.println(response.getMappings());
System.out.println(response.getSettings());
// 关闭
client.close();
3.3、删除索引
// 删除索引
DeleteIndexRequest request = new DeleteIndexRequest(\"order\");
AcknowledgedResponse response = client.indices().delete(request, RequestOptions.DEFAULT);
3.4、新增文档
// 修改数据
UpdateRequest updateRequest = new UpdateRequest();
updateRequest.index(\"order\").id(\"0001\");
updateRequest.doc(XContentType.JSON,\"price\",9999.98);
UpdateResponse response = client.update(updateRequest,RequestOptions.DEFAULT);
3.5、修改文档
// 修改数据
UpdateRequest updateRequest = new UpdateRequest();
updateRequest.index(\"order\").id(\"0001\");
updateRequest.doc(XContentType.JSON,\"price\",9999.98);
UpdateResponse response = client.update(updateRequest,RequestOptions.DEFAULT);
3.6、查看文档
// 查看数据
GetRequest indexRequest = new GetRequest();
indexRequest.index(\"order\").id(\"0001\");
GetResponse response = client.get(indexRequest,RequestOptions.DEFAULT);
3.7、删除文档
// 查看数据
DeleteRequest indexRequest = new DeleteRequest();
indexRequest.index(\"order\").id(\"0001\");
DeleteResponse response = client.delete(indexRequest,RequestOptions.DEFAULT);
3.8、批量新增文档
// 创建数据
BulkRequest indexRequest = new BulkRequest();
indexRequest.add(new IndexRequest().index(\"order\").id(\"1001\").source(XContentType.JSON,\"name\",\"笔\"));
indexRequest.add(new IndexRequest().index(\"order\").id(\"1002\").source(XContentType.JSON,\"name\",\"墨\"));
indexRequest.add(new IndexRequest().index(\"order\").id(\"1003\").source(XContentType.JSON,\"name\",\"纸\"));
indexRequest.add(new IndexRequest().index(\"order\").id(\"1004\").source(XContentType.JSON,\"name\",\"砚\"));
BulkResponse response = client.bulk(indexRequest, RequestOptions.DEFAULT);
3.9、批量删除文档
// 创建数据
BulkRequest indexRequest = new BulkRequest();
indexRequest.add(new DeleteRequest().index(\"order\").id(\"1001\"));
indexRequest.add(new DeleteRequest().index(\"order\").id(\"1002\"));
indexRequest.add(new DeleteRequest().index(\"order\").id(\"1003\"));
indexRequest.add(new DeleteRequest().index(\"order\").id(\"1004\"));
BulkResponse response = client.bulk(indexRequest, RequestOptions.DEFAULT);
3.10、全量、条件查询文档
// 全量查询
SearchRequest searchRequest = new SearchRequest();
searchRequest.indices(\"order\");
// 全量
//searchRequest.source(new SearchSourceBuilder().query(QueryBuilders.matchAllQuery()));
// 条件查询
searchRequest.source(new SearchSourceBuilder().query(QueryBuilders.termQuery(\"price\",49.99)));
SearchResponse response = client.search(searchRequest,RequestOptions.DEFAULT);
3.11、分页、排序、字段选择查询文档
// q全量查询
SearchRequest searchRequest = new SearchRequest();
searchRequest.indices(\"order\");
SearchSourceBuilder builder =new SearchSourceBuilder().query(QueryBuilders.matchAllQuery());
// 分页
builder.from(0);
builder.size(10);
// 排序
builder.sort(\"price\", SortOrder.DESC);
// 过滤字段
String [] exclude = {};
String [] include = {\"name\"};
builder.fetchSource(include,exclude);
searchRequest.source(builder);
3.12、组合查询文档
RestHighLevelClient client = new RestHighLevelClient(
RestClient.builder(new HttpHost(\"localhost\",9200,\"http\"))
);
SearchRequest searchRequest = new SearchRequest();
searchRequest.indices(\"order\");
SearchSourceBuilder builder = new SearchSourceBuilder();
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
boolQueryBuilder.must(QueryBuilders.matchQuery(\"price\",49.99));
// boolQueryBuilder.must(QueryBuilders.matchQuery(\"name\",\"纸\"));
boolQueryBuilder.should(QueryBuilders.matchQuery(\"name\",\"砚\"));
builder.query(boolQueryBuilder);
searchRequest.source(builder);
3.12、范围查询文档
RestHighLevelClient client = new RestHighLevelClient(
RestClient.builder(new HttpHost(\"localhost\",9200,\"http\"))
);
SearchRequest searchRequest = new SearchRequest();
searchRequest.indices(\"order\");
SearchSourceBuilder builder = new SearchSourceBuilder();
RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery(\"price\");
rangeQueryBuilder.gte(20);
rangeQueryBuilder.lte(1000);
builder.query(rangeQueryBuilder);
searchRequest.source(builder);
3.13、模糊查询文档
SearchSourceBuilder builder = new SearchSourceBuilder();
builder.query(QueryBuilders.fuzzyQuery(\"name\", \"笔\").fuzziness(Fuzziness.ONE));
searchRequest.source(builder);
SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
4、ElasticSearch 集群搭建
4.1、Windows下集群搭建
在Windows下进行集群搭建,首先修改conf文件夹下的 elasticsearch.yml,将这个作为第一个节点,
# 集群名称
cluster.name: my-application
# 节点信息
node.name: node-1
node.master: true
node.data: true
# 跨域配置
http.cors.enabled: true
http.cors.allow-origin: \"*\"
# ip地址
network.host: localhost
# http端口
http.port: 9201
# tcp监听端口
transport.tcp.port: 9301
而后复制一份作为节点二,节点二的配置需要新增配置:
# 去前一个结点找
discovery.seed_hosts: [\"localhost:9301\"]
discovery.zen.fd.ping_timeout: 1m
discovery.zen.fd.ping_retries: 5
分别启动节点一和节点二。访问地址:http://localhost:9201/_cluster/health
4.2、Linux下单机服务搭建
首先下载好对应的gz文件上传到linux服务器上。首先因为安全问题,Elasticsearch 不允许 root 用户直接运行,所以要创建新用户,在 root 用户中创建新用户:
useradd es #新增 es 用户
passwd es #为 es 用户设置密码
userdel -r es #如果错了,可以删除再加
chown -R es:123456 /tools/es #文件夹所有者
修改/tools/es/es-node1/config/elasticsearch.yml 文件
cluster.name: elasticsearch
node.name: node-1
network.host: 0.0.0.0
http.port: 9200
cluster.initial_master_nodes: [\"node-1\"]
修改/etc/security/limits.conf
# 每个进程可以打开的文件数的限制
es soft nofile 65536
es hard nofile 65536
修改/etc/security/limits.d/20-nproc.conf
# 每个进程可以打开的文件数的限制
es soft nofile 65536
es hard nofile 65536
# 操作系统级别对每个用户创建的进程数的限制
* hard nproc 4096
修改/etc/sysctl.conf
# 一个进程可以拥有的 VMA(虚拟内存区域)的数量,默认值为 65536
vm.max_map_count=655360
最后进行启动es:bin/elasticsearch
使用bin目录下的elasticsearch启动即可。
启动常出现的问题:
1、max file descriptors [4096] for elasticsearch process is too low, increase to at least [65536]
每个进程最大同时打开文件数太小,可通过下面2个命令查看当前数量
ulimit -Hn
ulimit -Sn
vi /etc/security/limits.conf文件,增加配置,用户退出后重新登录生效
* soft nofile 65536
* hard nofile 65536
2、max number of threads [3818] for user [es] is too low, increase to at least [4096]
问题同上,最大线程个数太低。修改配置文件/etc/security/limits.conf(和问题1是一个文件),增加配置
* soft nproc 4096
* hard nproc 4096
可通过命令查看
ulimit -Hu
ulimit -Su
3、启动之后进行访问9200端口显示无法访问
这个的问题也就是防火墙没有关闭,将防火墙关闭即可:
# 查看防火墙状态
systemctl status firewalld
# 暂时关闭防火墙
systemctl stop firewalld
# 永久关闭防火墙
systemctl enable firewalld.service
systemctl disable firewalld.service
启动后直接访问9200端口进行验证:
这里还是使用伪分布式来进行构建集群,首先修改conf下的elasticsearch.yml文件,将第一个节点作为一个master节点,里面的配置根据自身的linux集群进行修改即可。(比如说IP地址)这里在同一台服务器上启动三个es服务,只需要修改节点名称端口号即可。
#集群名称
cluster.name: cluster-es
#节点名称,每个节点的名称不能重复
node.name: node1
#ip 地址,每个节点的地址不能重复
network.host: 0.0.0.0
network.publish_host: 192.168.101.128
http.port: 9201
transport.tcp.port: 9301
#es7.x 之后新增的配置,节点发现
discovery.seed_hosts: [\"192.169.101.128:9301\",\"192.169.101.128:9302\",\"192.169.101.128:9303\"]
#es7.x 之后新增的配置,初始化一个新的集群时需要此配置来选举 master
cluster.initial_master_nodes: [\"node1\",\"node2\",\"node3\"]
gateway.recover_after_nodes: 2
http.cors.enabled: true
http.cors.allow-origin: \"*\"
其余的配置和当前节点一致,之后就可以直接进行启动这个该节点,其余两个节点也进行启动,启动之后可以分别进行访问对应的端口号 9201、9202、9203,可以看到集群搭建好之后所有的信息都是相同的,cluster_uuid是每个节点的id,这个是不同的。
集群节点总是kill
然后在这里启动es服务器,总是启动到一半就被killed掉,发现是内存不够了,由于ES是运行在JVM上,JVM本身除了分配的heap内存以外,还会用到一些堆外(off heap)内存。 在小内存的机器上跑ES,如果heap划分过多,累加上堆外内存后,总的JVM使用内存量可能超过物理内存限制。 如果swap又是关闭的情况下,就会被操作系统oom killer杀掉。后续原来是本身机器内存不够大,只有1G内存,而es中的jvm配置文件中,就配置了1g的堆大小,导致没有足够空间分配,故es启动不起来。,更改 jvm.options
文件:
-Xmx512m
-Xms512m
4.4、ElasticSreach-head 工具
github地址:https://github.com/mobz/elasticsearch-head
npm install
npm run start
启动项目之后直接访问对应的地址,首先我们连接到我们的集群就可以看到集群的相关信息了。
5、ElasticSearch 分布式集群
5.1、单节点集群
在包含一个空节点的集群内创建名为 users 的索引,将分配 3个主分片和一份副本(每个主分片拥有一个副本分片)
PUT请求 http://localhost:9201/user
{
\"settings\" : {
\"number_of_shards\" : 3,
\"number_of_replicas\" : 1
}
}
集群现在是拥有一个索引的单节点集群。3个主分片都被分配在node1,通过elasticSearch-head工具可以进行查看集群的分片状态。
当集群中只有一个节点在运行时,意味着会有一个单点故障问题——没有冗余。这个时候,我们只需再启动一个节点即可防止数据丢失。只需要在同一台机器上启动了第二个节点时,只要它和第一个节点有同样的 cluster.name 配置,它就会自动发现集群并加入到其中。但是在不同机器上启动节点的时候,为了加入到同一集群,你需要配置一个可连接到的单播主机列表。之所以配置为使用单播发现,以防止节点无意中加入集群。只有在同一台机器上运行的节点才会自动组成集群。如果启动了第二个节点,集群将会拥有两个节点的集群 : 所有主分片和副本分片都已被分配。
这个时候当启动了第三个节点,集群将会拥有三个节点的集群 : 这时会为了分散负载而对分片进行重新分配。
这时当我们想要扩容超过6个节点又该如何处理呢?
主分片的数目在索引创建时就已经确定了下来。实际上,这个数目定义了这个索引能够存储的最大数据量。但是,读操作搜索和返回数据可以同时被主分片或副本分片所处理,所以当拥有越多的副本分片时,也将拥有越高的吞吐量。在运行中的集群上是可以动态调整副本分片数目的,我们可以按需伸缩集群。
{
\"number_of_replicas\" : 2
}
5.4、应对故障(节点宕机)
当主节点突然宕机不可用。这时的集群必须拥有一个主节点来保证正常工作,所以发生的第一件事情就是选举一个新的主节点: Node 2 。在我们node1节点宕机的同时也失去了主分片1和2,并且在缺失主分片的时候索引也不能正常工作。 此时集群的状态将会变为red即不是所有主分片都在正常工作。
不过在其它节点上存在着这两个主分片的完整副本, 所以新的主节点立即将这些分片在 Node 2 和 Node 3 上对应的副本分片提升为主分片, 此时集群的状态将会为yellow。这个提升主分片的过程是瞬间发生的,所以没有办法在head上看到red的状态。
5.5、路由计算
当索引一个文档的时候,文档会被存储到一个主分片中。 es是如何把一个文档应该存放到哪个分片中呢?首先这肯定不会是随机的,否则将来要获取文档的时候我们就不知道从何处寻找了。实际上,这个过程是根据下面这个公式决定的:
shard = hash(routing) % number_of_primary_shards
routing 是一个可变值,默认是文档的 _id ,也可以设置成一个自定义的值。 routing 通过hash 函数生成一个数字,然后这个数字再除以 number_of_primary_shards (主分片的数量)后得到余数 。这个分布在 0 到 number_of_primary_shards-1 之间的余数,就是文档所在分片的位置。
5.6、分片控制
5.6.1、写流程
新建、索引和删除 请求都是 写 操作, 必须在主分片上面完成之后才能被复制到相关的副本分片
5.6.2、读流程
我们可以从主分片或者从其它任意副本分片检索文档
5.6.3、更新流程
5.7、分片原理
分片是ES最小的工作单元。传统的数据库每个字段存储单个值,但这对全文检索并不够。文本字段中的每个单词需要被搜索,对数据库意味着需要单个字段有索引多值的能力。最好的支持是一个字段多个值需求的数据结构是倒排索引。
5.8、倒排索引
ES使用一种称为倒排索引的结构,它适用于快速的全文搜索。有倒排索引,肯定会对应有正向索引。正向索引(forward index),反向索引(inverted index)更熟悉的名字是倒排索引。所谓的正向索引,就是搜索引擎会将待搜索的文件都对应一个文件ID,搜索时将这个ID和搜索关键字进行对应,形成 K-V 对,然后对关键字进行统计计数
5.9、Kibana
Kibana 是一个免费且开放的用户界面,能够让你对 Elasticsearch 数据进行可视化,并让你在 Elastic Stack 中进行导航。你可以进行各种操作,从跟踪查询负载,到理解请求如何流经你的整个应用,都能轻松完成。
下载地址:https://github.com/medcl/elasticsearch-analysis-ik/releases
下载地址:https://www.elastic.co/cn/downloads/past-releases#kibana 这里一定要装与ES相同的版本
下载之后进行解压,修改kibana.yml配置文件
server.port: 5601
elasticsearch.hosts: [\"http://localhost:9201\"]
kibana.index : \".kibana\"
i18n.locale: \"zh-CN\"
先启动Es,之后启动kibana(在bin目录下启动)。
6、Spring 集成 ElasticSearch
6.1、项目初始化
首先这里还是先创建一个Maven项目,后续的依赖配置再往里面添加就行。或者也可以直接使用springboot快速初始化,这里先导入相关依赖。
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-data-elasticsearchartifactId>
dependency>
添加相对应的配置:
server.port=8989
elasticsearch.host=127.0.0.1
elasticsearch.port=9200
logging.level.com.lzq=debug
在这里添加一个实体类,用来做ES的索引映射
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
@Document(indexName = \"product\", shards = 3, replicas = 1)
public class Product {
@Id
private Long id;
/**
* type : 字段数据类型
* analyzer : 分词器类型
* index : 是否索引(默认:true)
* Keyword : 短语,不进行分词
*/
@Field(type = FieldType.Text, analyzer = \"ik_max_word\")
private String title;
@Field(type = FieldType.Keyword)
private String category;
@Field(type = FieldType.Double)
private Double price;
@Field(type = FieldType.Keyword, index = false)
private String images;
}
添加一个Dao接口,继承至ElasticsearchRepository类,ElasticsearchRepository类封装了一系列对ES操作的方法,这里的这个就类似于Mybatis-Plus的BaseMapper一样。
@Repository
public interface ProductDao extends ElasticsearchRepository<Product,Long> {
}
最后添加一个配置类
@ConfigurationProperties(prefix = \"elasticsearch\")
@Configuration
@Data
public class EsConfig extends AbstractElasticsearchConfiguration {
private String host;
private Integer port;
@Override
public RestHighLevelClient elasticsearchClient() {
RestClientBuilder builder = RestClient.builder(new HttpHost(host, port));
RestHighLevelClient restHighLevelClient = new
RestHighLevelClient(builder);
return restHighLevelClient;
}
}
6.2、索引操作
在这里就直接使用springBoot提供的test测试来进行测试,
6.2.1、创建索引
这里直接启动服务,或者通过这里的Test对程序进行编译,这里的索引会通过实体类进行创建,创建完成之后可以通过:http://localhost:9200/_cat/indices?v
进行查看所有索引
@Test
public void createIndex(){
//创建索引,系统初始化会自动创建索引
System.out.println(\"创建索引\");
}
6.2.2、删除索引
在这里需要先将ElasticsearchRestTemplate 这个模板进行注入,之后的操作都可以直接通过这个模板封装的方法进行操作。
@Autowired
private ElasticsearchRestTemplate elasticsearchRestTemplate;
@Test
public void deleteIndex(){
boolean flg = elasticsearchRestTemplate.deleteIndex(Product.class);
System.out.println(\"删除索引 = \" + flg);
}
6.3、文档操作
这里的文档操作还是使用到ProductDao这个接口实现的父类提供的方法来进行操作。
@Autowired
private ProductDao productDao
@Test
public void insert(){
Product product = new Product();
product.setId(1L);
product.setCategory(\"miao shu\");
product.setImages(\"image address\");
product.setPrice(50.0);
product.setTitle(\"title 1\");
// 新增和修改使用的是同样的方法。判断id是否存在自动进行新增修改
productDao.save(product);
}
@Test
public void find(){
Product product = productDao.findById(1L).get();
System.out.println(product);
}
@Test
public void findAll(){
Iterable<Product> all = productDao.findAll();
for (Product product : all){
System.out.println(product);
}
}
@Test
public void delete(){
Product product = new Product();
product.setId(2L);
productDao.delete(product);
}
@Test
public void insertAll(){
List<Product> productList = new ArrayList<>();
for (int i =0;i<10;i++){
Product product = new Product();
product.setId(Long.valueOf(i));
product.setTitle(\"title[\"+i+\"]\");
product.setCategory(\"category\"+i);
product.setPrice(1999.0+i);
product.setImages(\"image\"+i);
productList.add(product);
}
productDao.saveAll(productList);
}
@Test
public void page(){
Sort sort = Sort.by(Sort.Direction.DESC,\"id\");
int currentPage=0;
int pageSize = 5;
//设置查询分页
PageRequest pageRequest = PageRequest.of(currentPage, pageSize,sort);
Page<Product> productPage = productDao.findAll(pageRequest);
for (Product product : productPage.getContent()) {
System.out.println(product);
}
}
6.4、文档搜索
@Test
public void termQuery() {
TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery(\"title\", \"5\");
Iterable<Product> products = productDao.search(termQueryBuilder);
for (Product product : products) {
System.out.println(product);
}
}
@Test
public void termQueryByPage() {
int currentPage = 0;
int pageSize = 5;
//设置查询分页
PageRequest pageRequest = PageRequest.of(currentPage, pageSize);
TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery(\"title\", \"title\");
Iterable<Product> products = productDao.search(termQueryBuilder, pageRequest);
for (Product product : products) {
System.out.println(product);
}
}
7、ElasticSearch 优化
7.1、硬件选择
Elasticsearch 的基础是 Lucene,所有的索引和文档数据是存储在本地的磁盘中,磁盘能处理的吞吐量越大,节点就越稳定。
7.2、分片策略
7.2.1、合理设置分片数
分片和副本的设计为 ES 提供了支持分布式和故障转移的特性,但并不表示分片和副本是可以无限分配的。而且索引的分片完成分配后由于索引的路由机制,是不能重新修改分片数的。
并且这里的分片也不是越大越好的,这是因为:
所以这里对于分片也需要进行设置调整
7.2.2、推迟分片分配
对于节点瞬时中断的问题,默认情况,集群会等待一分钟来查看节点是否会重新加入,如果这个节点在此期间重新加入,重新加入的节点会保持其现有的分片数据,不会触发新的分片分配。这样就可以减少 ES 在自动再平衡可用分片时所带来的极大开销。通过修改参数 delayed_timeout ,可以延长再均衡的时间,可以全局设置也可以在索引
级别进行修改:
PUT /_all/_settings
{
\"settings\": {
\"index.unassigned.node_left.delayed_timeout\": \"5m\"
}
}
7.3、路由选择
当我们查询文档的时候,Elasticsearch 如何知道一个文档应该存放到哪个分片中呢?它其实是通过下面这个公式来计算出来:routing 默认值是文档的 id,也可以采用自定义值,比如用户 id
shard = hash(routing) % number_of_primary_shards
不带 routing 查询
在查询的时候因为不知道要查询的数据具体在哪个分片上,所以整个过程分为 2 个步骤
带 routing 查询
查询的时候,可以直接根据 routing 信息定位到某个分配查询,不需要查询所有的分配,经过协调节点排序。向上面自定义的用户查询,如果 routing 设置为 userid 的话,就可以直接查询出数据来,效率提升很多。
7.4、写入速度优化
7.4.1、批量数据提交
ES 提供了 Bulk API 支持批量操作,当我们有大量的写任务时,可以使用 Bulk 来进行批量写入。
通用的策略如下:Bulk 默认设置批量提交的数据量不能超过 100M。数据条数一般是根据文档的大小和服务器性能而定的,但是单次批处理的数据大小应从 5MB~15MB 逐渐增加,当性能没有提升时,把这个数据量作为最大值。
7.4.2、合理使用合并
Lucene 以段的形式存储数据。当有新的数据写入索引时,Lucene 就会自动创建一个新的段。随着数据量的变化,段的数量会越来越多,消耗的多文件句柄数及 CPU 就越多,查询效率就会下降。由于 Lucene 段合并的计算量庞大,会消耗大量的 I/O,所以 ES 默认采用较保守的策略,让后台定期进行段合并
7.4.3、减少 Refresh 的次数
Lucene 在新增数据时,采用了延迟写入的策略,默认情况下索引的 refresh_interval 为1 秒。Lucene 将待写入的数据先写到内存中,超过 1 秒(默认)时就会触发一次 Refresh,然后 Refresh 会把内存中的的数据刷新到操作系统的文件缓存系统中。如果我们对搜索的实效性要求不高,可以将 Refresh 周期延长,例如 30 秒。这样还可以有效地减少段刷新次数,但这同时意味着需要消耗更多的 Heap 内存。
7.4.4、加大 Flush 设置
Flush 的主要目的是把文件缓存系统中的段持久化到硬盘,当 Translog 的数据量达到512MB 或者 30 分钟时,会触发一次 Flush。index.translog.flush_threshold_size 参数的默认值是 512MB,进行修改。增加参数值意味着文件缓存系统中可能需要存储更多的数据,所以我们需要为操作系统的文件缓存系统留下足够的空间。
7.4.5、减少副本的数量
ES 为了保证集群的可用性,提供了 Replicas(副本)支持,然而每个副本也会执行分析、索引及可能的合并过程,所以 Replicas 的数量会严重影响写索引的效率。当写索引时,需要把写入的数据都同步到副本节点,副本节点越多,写索引的效率就越慢。如果需要大批量进行写入操 作,可 以先禁止Replica复 制,设 置index.number_of_replicas: 0 关闭副本。在写入完成后,Replica 修改回正常的状态。
7.5、内存设置
ES 默认安装后设置的内存是 1GB,对于任何一个现实业务来说,这个设置都太小了。在 ES 安装文件中包含一个 jvm.option 文件,添加如下命令来设置 ES 的堆大小,Xms 表示堆的初始大小,Xmx 表示可分配的最大内存,都是 1GB。确保 Xmx 和 Xms 的大小是相同的,其目的是为了能够在 Java 垃圾回收机制清理完堆区后不需要重新分隔计算堆区的大小而浪费资源,可以减轻伸缩堆大小带来的压力。
ES堆内存的分配需要满足以下两个原则:
7.6、配置说明
参数名 | 参数值 | 说明 |
---|---|---|
cluster.name | elasticsearch | 配置 ES 的集群名称,默认值是 ES,建议改成与所存数据相关的名称,ES 会自动发现在同一网段下的集群名称相同的节点 |
node.name | node-1 | 集群中的节点名,在同一个集群中不能重复。节点的名称一旦设置,就不能再改变了。当然,也可以设 置 成 服 务器的主机名 称 , 例 如node.name:${HOSTNAME}。 |
node.master | true | 指定该节点是否有资格被选举成为 Master 节点,默认是 True,如果被设置为 True,则只是有资格成为Master 节点,具体能否成为 Master 节点,需要通过选举产生。 |
node.data | true | 指定该节点是否存储索引数据,默认为 True。数据的增、删、改、查都是在 Data 节点完成的。 |
index.number_of_shards | 1 | 设置都索引分片个数,默认是 1 片。也可以在创建索引时设置该值,具体设置为多大都值要根据数据量的大小来定。如果数据量不大,则设置成 1 时效率最高 |
index.number_of_replicas | 1 | 设置默认的索引副本个数,默认为 1 个。副本数越多,集群的可用性越好,但是写索引时需要同步的数据越多。 |
transport.tcp.compress | true | 设置在节点间传输数据时是否压缩,默认为 False,不压缩 |
discovery.zen.minimum_master_nodes | 1 | 设置在选举 Master 节点时需要参与的最少的候选主节点数,默认为 1。如果使用默认值,则当网络不稳定时有可能会出现脑裂。合理的数值为 (master_eligible_nodes/2)+1 ,其中master_eligible_nodes 表示集群中的候选主节点数 |
discovery.zen.ping.timeout | 3s | 设置在集群中自动发现其他节点时 Ping 连接的超时时间,默认为 3 秒。在较差的网络环境下需要设置得大一点,防止因误判该节点的存活状态而导致分片的转移 |
8、ElasticSearch 总结
8.1、为什么要用 ES
系统中的数据,随着业务的发展,时间的推移,将会非常多,而业务中往往采用模糊查询进行数据的搜索,而模糊查询会导致查询引擎放弃索引,导致系统查询数据时都是全表扫描,在百万级别的数据库中,查询效率是非常低下的,而我们使用 ES 做一个全文索引,将经常查询的系统功能的某些字段作为ES的索引进行查询。
8.2、ES master节点选举流程
8.3、ES 集群脑裂的原因和解决方案
出现脑裂的原因:
解决方案
8.4、ES 查询文档流程
协调节点默认使用文档 ID 参与计算(也支持通过 routing),以便为路由提供合适的分片:
shard = hash(document_id) % (num_of_primary_shards)
当分片所在的节点接收到来自协调节点的请求后,会将请求写入到 Memory Buffer,然后定时(默认是每隔 1 秒)写入到 Filesystem Cache,这个从 Memory Buffer 到 Filesystem Cache 的过程就叫做 refresh;
当然在某些情况下,存在 Momery Buffer 和 Filesystem Cache 的数据可能会丢失,ES 是通过 translog的机制来保证数据的可靠性的。其实现机制是接收到请求后,同时也会写入到 translog 中,当 Filesystem cache 中的数据写入到磁盘中时,才会清除掉,这个过程叫做 flush;
在 flush 过程中,内存中的缓冲将被清除,内容被写入一个新段,段的 fsync 将创建一个新的提交点,并将内容刷新到磁盘,旧的 translog 将被删除并开始一个新的 translog。
flush 触发的时机是定时触发(默认 30 分钟)或者 translog 变得太大(默认为 512M)时;
8.5、ES 更新删除文档流程
8.6、在并发情况下,ES 数据如果保证读写一致