Elasticsearch集群 / Java客户端

6.1、集群节点

ELasticsearch的集群是由多个节点组成的，通过cluster.name设置集群名称，并且用于区分其它的集群，每个节点
通过node.name指定节点的名称。
在Elasticsearch中，节点的类型主要有4种：

• master节点     

          配置文件中node.master属性为true(默认为true)，就有资格被选为master节点。

          master节点用于控制整个集群的操作。比如创建或删除索引，管理其它非master节点等。

• data节点

       配置文件中node.data属性为true(默认为true)，就有资格被设置成data节点。

      data节点主要用于执行数据相关的操作。比如文档的CRUD。

• 客户端节点

       配置文件中node.master属性和node.data属性均为false。

       该节点不能作为master节点，也不能作为data节点。
       可以作为客户端节点，用于响应用户的请求，把请求转发到其他节点

• 部落节点

       当一个节点配置tribe.*的时候，它是一个特殊的客户端，它可以连接多个集群，在所有连接的集群上执行
       搜索和其他操作。

6.2、搭建集群

#启动3个虚拟机，分别在3台虚拟机上部署安装Elasticsearch
mkdir /admin/es-cluster

#分发到其它机器
scp -r es-cluster elsearch@192.168.40.134:/admin
#node01的配置：
cluster.name: es-admin-cluster
node.name: node01
node.master: true
node.data: true
network.host: 0.0.0.0
http.port: 9200
discovery.zen.ping.unicast.hosts: ["192.168.40.133","192.168.40.134","192.168.40.135"]
discovery.zen.minimum_master_nodes: 2
http.cors.enabled: true
http.cors.allow-origin: "*"

#node02的配置：
cluster.name: es-admin-cluster
node.name: node02
node.master: true
node.data: true
network.host: 0.0.0.0
http.port: 9200
discovery.zen.ping.unicast.hosts: ["192.168.40.133","192.168.40.134","192.168.40.135"]
discovery.zen.minimum_master_nodes: 2
http.cors.enabled: true
http.cors.allow-origin: "*"


#node03的配置：
cluster.name: es-admin-cluster
node.name: node02
node.master: true
node.data: true
network.host: 0.0.0.0
http.port: 9200
discovery.zen.ping.unicast.hosts: ["192.168.40.133","192.168.40.134","192.168.40.135"]
discovery.zen.minimum_master_nodes: 2
http.cors.enabled: true
http.cors.allow-origin: "*"
#分别启动3个节点
./elasticsearch

查看集群

 创建索引：

 查询集群状态：/_cluster/health

响应：

{ 
  cluster_name: "es-admin-cluster"
  status: "green"
  timed_out: false
  number_of_nodes: 3
  number_of_data_nodes: 3
  active_primary_shards: 5
  active_shards: 10
  relocating_shards: 0
  initializing_shards: 0
  unassigned_shards: 0
  delayed_unassigned_shards: 0
  number_of_pending_tasks: 0
  number_of_in_flight_fetch: 0
  task_max_waiting_in_queue_millis: 0
  active_shards_percent_as_number: 100
}

集群状态的三种颜色：

6.3、分片和副本

为了将数据添加到Elasticsearch，我们需要索引(index)——一个存储关联数据的地方。实际上，索引只是一个用来
指向一个或多个分片(shards)的“逻辑命名空间(logical namespace)”.

• 一个分片(shard)是一个最小级别“工作单元(worker unit)”,它只是保存了索引中所有数据的一部分。
• 我们需要知道是分片就是一个Lucene实例，并且它本身就是一个完整的搜索引擎。应用程序不会和它直接通信。
• 分片可以是主分片(primary shard)或者是复制分片(replica shard)。
• 索引中的每个文档属于一个单独的主分片，所以主分片的数量决定了索引最多能存储多少数据。
• 复制分片只是主分片的一个副本，它可以防止硬件故障导致的数据丢失，同时可以提供读请求，比如搜索或者从别的shard取回文档。
• 当索引创建完成的时候，主分片的数量就固定了，但是复制分片的数量可以随时调整。

6.4、故障转移

6.4.1、将data节点停止

这里选择将node02停止：

 说明：

当前集群状态为黄色，表示主节点可用，副本节点不完全可用

 过一段时间观察，发现节点列表中看不到node02，副本节点分配到了node01和node03，集群状态恢复到绿色。

 将node02恢复:

./node02/bin/elasticsearch

 可以看到，node02恢复后，重新加入了集群，并且重新分配了节点信息。

6.4.2、将master节点停止

 接下来，测试将node01停止，也就是将主节点停止。

 从结果中可以看出，集群对master进行了重新选举，选择node03为master。并且集群状态变成黄色。
等待一段时间后，集群状态从黄色变为了绿色：

 恢复node01节点：

./node01/bin/elasticsearch 

重启之后，发现node01可以正常加入到集群中，集群状态依然为绿色：

 特别说明：
如果在配置文件中discovery.zen.minimum_master_nodes设置的不是N/2+1时，会出现脑裂问题，之前宕机
的主节点恢复后不会加入到集群。

 6.5、分布式文档

 6.5.1、路由

首先，来看个问题：

 如图所示：当我们想一个集群保存文档时，文档该存储到哪个节点呢？ 是随机吗？ 是轮询吗？
实际上，在ELasticsearch中，会采用计算的方式来确定存储到哪个节点，计算公式如下：

shard = hash(routing) % number_of_primary_shards 

•  routing值是一个任意字符串，它默认是_id但也可以自定义。
• 这个routing字符串通过哈希函数生成一个数字，然后除以主切片的数量得到一个余数(remainder)，余数的范围永远是0到number_of_primary_shards - 1，这个数字就是特定文档所在的分片。

这就是为什么创建了主分片后，不能修改的原因。

6.5.2、文档的写操作

新建、索引和删除请求都是写(write)操作，它们必须在主分片上成功完成才能复制到相关的复制分片上。

下面我们罗列在主分片和复制分片上成功新建、索引或删除一个文档必要的顺序步骤：

1. 客户端给 Node 1 发送新建、索引或删除请求。
2. 节点使用文档的 _id 确定文档属于分片 0 。它转发请求到 Node 3 ，分片 0 位于这个节点上。
3. Node 3 在主分片上执行请求，如果成功，它转发请求到相应的位于 Node 1 和 Node 2 的复制节点上。当所有
的复制节点报告成功， Node 3 报告成功到请求的节点，请求的节点再报告给客户端。

客户端接收到成功响应的时候，文档的修改已经被应用于主分片和所有的复制分片。你的修改生效了。

6.5.3、搜索文档（单个文档）

文档能够从主分片或任意一个复制分片被检索

 下面我们罗列在主分片或复制分片上检索一个文档必要的顺序步骤：
   1. 客户端给 Node 1 发送get请求。
   2. 节点使用文档的 _id 确定文档属于分片 0 。分片 0 对应的复制分片在三个节点上都有。此时，它转发请求到
      Node 2 。
   3. Node 2 返回文档(document)给 Node 1 然后返回给客户端。
对于读请求，为了平衡负载，请求节点会为每个请求选择不同的分片——它会循环所有分片副本。
可能的情况是，一个被索引的文档已经存在于主分片上却还没来得及同步到复制分片上。这时复制分片会报告文档未
找到，主分片会成功返回文档。一旦索引请求成功返回给用户，文档则在主分片和复制分片都是可用的。

6.5.4、全文搜索

对于全文搜索而言，文档可能分散在各个节点上，那么在分布式的情况下，如何搜索文档呢？
搜索，分为2个阶段，搜索（query）+取回（fetch）。

搜索（query）

 查询阶段包含以下三步：
    1. 客户端发送一个 search（搜索） 请求给 Node 3 , Node 3 创建了一个长度为 from+size 的空优先级队
    2. Node 3 转发这个搜索请求到索引中每个分片的原本或副本。每个分片在本地执行这个查询并且结果将结果到
        一个大小为 from+size 的有序本地优先队列里去。
   3. 每个分片返回document的ID和它优先队列里的所有document的排序值给协调节点 Node 3 。 Node 3 把这些
       值合并到自己的优先队列里产生全局排序结果。

取回（fetch）

 分发阶段由以下步骤构成：
      1. 协调节点辨别出哪个document需要取回，并且向相关分片发出 GET 请求。
      2. 每个分片加载document并且根据需要丰富（enrich）它们，然后再将document返回协调节点。
      3. 一旦所有的document都被取回，协调节点会将结果返回给客户端。

7、Java客户端

在Elasticsearch中，为java提供了2种客户端，一种是REST风格的客户端，另一种是Java API的客户端。https://www.elastic.co/guide/en/elasticsearch/client/index.html

 7.1、REST客户端

 Elasticsearch提供了2种REST客户端，一种是低级客户端，一种是高级客户端。

• Java Low Level REST Client：官方提供的低级客户端。该客户端通过http来连接Elasticsearch集群。用户在使用该客户端时需要将请求数据手动拼接成Elasticsearch所需JSON格式进行发送，收到响应时同样也需要将返回的JSON数据手动封装成对象。虽然麻烦，不过该客户端兼容所有的Elasticsearch版本。
• Java High Level REST Client：官方提供的高级客户端。该客户端基于低级客户端实现，它提供了很多便捷的API来解决低级客户端需要手动转换数据格式的问题。

7.2、构造数据

POST /haoke/house/_bulk
{"index":{"_index":"haoke","_type":"house"}}
{"id":"1001","title":"整租 · 南丹大楼 1居室 7500","price":"7500"}
{"index":{"_index":"haoke","_type":"house"}}
{"id":"1002","title":"陆家嘴板块，精装设计一室一厅，可拎包入住诚意租。","price":"8500"}
{"index":{"_index":"haoke","_type":"house"}}
{"id":"1003","title":"整租 · 健安坊 1居室 4050","price":"7500"}
{"index":{"_index":"haoke","_type":"house"}}
{"id":"1004","title":"整租 · 中凯城市之光+视野开阔+景色秀丽+拎包入住","price":"6500"}
{"index":{"_index":"haoke","_type":"house"}}
{"id":"1005","title":"整租 · 南京西路品质小区 21213三轨交汇 配套齐* 拎包入住","price":"6000"}
{"index":{"_index":"haoke","_type":"house"}}
{"id":"1006","title":"祥康里 简约风格 *南户型 拎包入住 看房随时","price":"7000"}

7.3、REST低级客户端

 7.3.1、创建工程

创建工程admin-elasticsearch：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
    <!--路径改为实际路径-->
  <groupId>cn.china.elasticsearch</groupId>
  <artifactId>admin-elasticsearch</artifactId>
  <version>1.0-SNAPSHOT</version>
  <dependencies>
    <dependency>
      <groupId>org.elasticsearch.client</groupId>
      <artifactId>elasticsearch-rest-client</artifactId>
      <version>6.5.4</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.9.4</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <!-- java编译插件 -->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.2</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
          <encoding>UTF-8</encoding>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

7.3.2、编写测试用例

package cn.china.es.rest;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.http.HttpHost;
import org.apache.http.util.EntityUtils;
import org.elasticsearch.client.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
public class TestESREST {
  private static final ObjectMapper MAPPER = new ObjectMapper();
  private RestClient restClient;
  @Before
  public void init() {
    RestClientBuilder restClientBuilder = RestClient.builder(
        new HttpHost("172.16.55.185", 9200, "http"),
        new HttpHost("172.16.55.185", 9201, "http"),
        new HttpHost("172.16.55.185", 9202, "http"));
    restClientBuilder.setFailureListener(new RestClient.FailureListener() {
      @Override
      public void onFailure(Node node) {
        System.out.println("出错了 -> " + node);
     }
   });
    this.restClient = restClientBuilder.build();
 }
  @After
  public void after() throws IOException {
     restClient.close();
 }
  // 查询集群状态
  @Test
  public void testGetInfo() throws IOException {
    Request request = new Request("GET", "/_cluster/state");
    request.addParameter("pretty","true");
    Response response = this.restClient.performRequest(request);
    System.out.println(response.getStatusLine());
    System.out.println(EntityUtils.toString(response.getEntity()));
 }
  // 新增数据
  @Test
  public void testCreateData() throws IOException {
    Request request = new Request("POST", "/haoke/house");
    Map<String, Object> data = new HashMap<>();
    data.put("id","2001");
    data.put("title","张江高科");
    data.put("price","3500");
    request.setJsonEntity(MAPPER.writeValueAsString(data));
    Response response = this.restClient.performRequest(request);
    System.out.println(response.getStatusLine());
    System.out.println(EntityUtils.toString(response.getEntity()));
 }
  // 根据id查询数据
  @Test
  public void testQueryData() throws IOException {
    Request request = new Request("GET", "/haoke/house/G0pfE2gBCKv8opxuRz1y");
    Response response = this.restClient.performRequest(request);
    System.out.println(response.getStatusLine());
    System.out.println(EntityUtils.toString(response.getEntity()));
 }
  // 搜索数据
  @Test
  public void testSearchData() throws IOException {
    Request request = new Request("POST", "/haoke/house/_search");
    String searchJson = "{\"query\": {\"match\": {\"title\": \"拎包入住\"}}}";
    request.setJsonEntity(searchJson);
    request.addParameter("pretty","true");
    Response response = this.restClient.performRequest(request);
    System.out.println(response.getStatusLine());
    System.out.println(EntityUtils.toString(response.getEntity()));
 }
}

7.4、REST高级客户端

7.4.1、引入依赖

<dependency>
  <groupId>org.elasticsearch.client</groupId>
  <artifactId>elasticsearch-rest-high-level-client</artifactId>
  <version>6.5.4</version>
</dependency>

7.4.2、编写测试用例

package cn.china.es.rest;
import org.apache.http.HttpHost;
import org.elasticsearch.action.ActionListener;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.Strings;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
public class TestRestHighLevel {
  private RestHighLevelClient client;
  @Before
  public void init() {
    RestClientBuilder restClientBuilder = RestClient.builder(
        new HttpHost("172.16.55.185", 9200, "http"),
        new HttpHost("172.16.55.185", 9201, "http"),
        new HttpHost("172.16.55.185", 9202, "http"));
    this.client = new RestHighLevelClient(restClientBuilder);
 }
  @After
  public void after() throws Exception {
    this.client.close();
 }
  /**
  * 新增文档，同步操作
  *
  * @throws Exception
  */
  @Test
  public void testCreate() throws Exception {
    Map<String, Object> data = new HashMap<>();
    data.put("id", "2002");
    data.put("title", "南京西路 拎包入住 一室一厅");
    data.put("price", "4500");
    IndexRequest indexRequest = new IndexRequest("haoke", "house")
       .source(data);
    IndexResponse indexResponse = this.client.index(indexRequest,
RequestOptions.DEFAULT);
    System.out.println("id->" + indexResponse.getId());
    System.out.println("index->" + indexResponse.getIndex());
    System.out.println("type->" + indexResponse.getType());
    System.out.println("version->" + indexResponse.getVersion());
    System.out.println("result->" + indexResponse.getResult());
    System.out.println("shardInfo->" + indexResponse.getShardInfo());
 }
  /**
  * 新增文档，异步操作
  *
  * @throws Exception
   */
  @Test
  public void testCreateAsync() throws Exception {
    Map<String, Object> data = new HashMap<>();
    data.put("id", "2003");
    data.put("title", "南京东路 最新房源 二室一厅");
    data.put("price", "5500");
    IndexRequest indexRequest = new IndexRequest("haoke", "house")
       .source(data);
    this.client.indexAsync(indexRequest, RequestOptions.DEFAULT, new
ActionListener<IndexResponse>() {
      @Override
      public void onResponse(IndexResponse indexResponse) {
        System.out.println("id->" + indexResponse.getId());
        System.out.println("index->" + indexResponse.getIndex());
        System.out.println("type->" + indexResponse.getType());
        System.out.println("version->" + indexResponse.getVersion());
        System.out.println("result->" + indexResponse.getResult());
        System.out.println("shardInfo->" + indexResponse.getShardInfo());
     }
      @Override
      public void onFailure(Exception e) {
        System.out.println(e);
     }
   });
   
    System.out.println("ok");
    Thread.sleep(20000);
 }
  @Test
  public void testQuery() throws Exception {
    GetRequest getRequest = new GetRequest("haoke", "house",
"GkpdE2gBCKv8opxuOj12");
    // 指定返回的字段
    String[] includes = new String[]{"title", "id"};
    String[] excludes = Strings.EMPTY_ARRAY;
    FetchSourceContext fetchSourceContext =
        new FetchSourceContext(true, includes, excludes);
    getRequest.fetchSourceContext(fetchSourceContext);
    GetResponse response = this.client.get(getRequest, RequestOptions.DEFAULT);
    System.out.println("数据 -> " + response.getSource());
 }
   /**
  * 判断是否存在
  *
  * @throws Exception
  */
  @Test
  public void testExists() throws Exception {
    GetRequest getRequest = new GetRequest("haoke", "house",
"GkpdE2gBCKv8opxuOj12");
    // 不返回的字段
    getRequest.fetchSourceContext(new FetchSourceContext(false));
    boolean exists = this.client.exists(getRequest, RequestOptions.DEFAULT);
    System.out.println("exists -> " + exists);
 }
  /**
  * 删除数据
  *
  * @throws Exception
  */
  @Test
  public void testDelete() throws Exception {
    DeleteRequest deleteRequest = new DeleteRequest("haoke", "house",
"GkpdE2gBCKv8opxuOj12");
    DeleteResponse response = this.client.delete(deleteRequest,
RequestOptions.DEFAULT);
    System.out.println(response.status());// OK or NOT_FOUND
 }
  /**
  * 更新数据
  *
  * @throws Exception
  */
  @Test
  public void testUpdate() throws Exception {
    UpdateRequest updateRequest = new UpdateRequest("haoke", "house",
"G0pfE2gBCKv8opxuRz1y");
    Map<String, Object> data = new HashMap<>();
    data.put("title", "张江高科2");
    data.put("price", "5000");
    updateRequest.doc(data);
    UpdateResponse response = this.client.update(updateRequest,
RequestOptions.DEFAULT);
    System.out.println("version -> " + response.getVersion());
 }



   /**
  * 测试搜索
  *
  * @throws Exception
  */
  @Test
  public void testSearch() throws Exception {
    SearchRequest searchRequest = new SearchRequest("haoke");
    searchRequest.types("house");
    SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
    sourceBuilder.query(QueryBuilders.matchQuery("title", "拎包入住"));
    sourceBuilder.from(0);
    sourceBuilder.size(5);
    sourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
    searchRequest.source(sourceBuilder);
    SearchResponse search = this.client.search(searchRequest,
RequestOptions.DEFAULT);
    System.out.println("搜索到 " + search.getHits().totalHits + " 条数据.");
    SearchHits hits = search.getHits();
    for (SearchHit hit : hits) {
      System.out.println(hit.getSourceAsString());
   }
 }
}

 参考资料:

https://www.bilibili.com/video/av67957955/?p=56&t=49