使用java客户端连接es集群，配置多个节点

最新推荐文章于 2025-04-06 09:57:59 发布

wangyibo123ok

最新推荐文章于 2025-04-06 09:57:59 发布

阅读量4.1k

点赞数

文章标签： java elasticsearch linux

本文链接：https://blog.youkuaiyun.com/wangyibo123ok/article/details/131649893

版权

使用java客户端连接一个集群，如果一个ES集群中某个节点挂了，正好又是java所连接的。这就出现了单点问题。

解决方式1

使用多个初始主机：在 Java 客户端的连接配置中，可以指定多个初始主机（节点）的地址。这样，如果一个节点不可用，客户端可以尝试连接到其他节点。

在 Java 客户端中，你可以使用 Elasticsearch 提供的官方 Java 客户端库（Elasticsearch Java High-Level REST Client）来连接到 Elasticsearch 集群，并指定多个初始主机（节点）的地址。以下是一个简单的示例代码：

import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;

import java.util.Arrays;
import java.util.List;

public class ElasticsearchClientExample {
    public static void main(String[] args) {
        // 定义多个初始主机地址
        List<String> initialHosts = Arrays.asList("host1:9200", "host2:9200", "host3:9200");

        // 创建 RestClientBuilder，设置初始主机地址
        RestClientBuilder builder = RestClient.builder(initialHosts.toArray(new String[0]));

        // 创建 RestHighLevelClient
        RestHighLevelClient client = new RestHighLevelClient(builder);

        // 使用 client 进行操作，如执行搜索、索引文档等
        // ...

        // 关闭 client
        try {
            client.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在上述示例中，首先定义了一个包含多个初始主机地址的列表 initialHosts。然后，我们使用 RestClient.builder() 方法创建 RestClientBuilder 对象，并将初始主机地址传递给它。最后，我们使用 RestHighLevelClient 类创建一个 Elasticsearch 高级客户端实例 client。

通过指定多个初始主机地址，当一个节点不可用时，客户端会尝试连接到其他节点。Elasticsearch 客户端库会自动处理节点的故障转移和重试连接等逻辑。

请确保将实际的主机地址替换为你的 Elasticsearch 集群中实际可用的节点地址。另外，你还可以根据需要设置其他连接配置，例如设置连接超时时间、控制连接数等。详细的配置信息可以参考 Elasticsearch 官方文档和 Java 客户端库的文档

解决方式2(简单粗暴)

如果你在 Java 客户端连接 Elasticsearch 集群时使用集群名称而不是具体节点的主机名或 IP 地址，可以解决单点故障的问题。当一个节点挂掉时，客户端会自动尝试连接到其他可用节点，而不会依赖于单个节点。

以下是一个示例代码片段，展示如何使用集群名称连接 Elasticsearch 集群：

import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;

public class ElasticsearchClientExample {
    public static void main(String[] args) {
        // 定义 Elasticsearch 集群的名称
        String clusterName = "your-cluster-name";

        // 创建 RestClientBuilder，设置集群名称
        RestClientBuilder builder = RestClient.builder(clusterName);

        // 创建 RestHighLevelClient
        RestHighLevelClient client = new RestHighLevelClient(builder);

        // 使用 client 进行操作，如执行搜索、索引文档等
        // ...

        // 关闭 client
        try {
            client.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在上述示例中，将集群名称传递给 RestClient.builder() 方法来创建 RestClientBuilder 对象。然后，使用 RestHighLevelClient 类创建一个 Elasticsearch 高级客户端实例 client。

使用集群名称连接 Elasticsearch 集群时，客户端会自动发现可用的节点，并在需要时进行故障转移。这样，即使一个节点挂掉，客户端仍然能够连接到其他可用节点，从而避免了单点故障。

确保将实际的集群名称替换为你的 Elasticsearch 集群的名称。另外，你还可以根据需要设置其他连接配置，例如设置连接超时时间、控制连接数等。

解决方式3

使用重试机制：在 Java 客户端代码中实现重试机制，当与一个节点的连接失败时，尝试连接其他节点。你可以设置最大重试次数和重试间隔，确保在节点故障时进行重试连接

使用连接池：使用连接池可以管理多个与 Elasticsearch 集群的连接，并在需要时自动重试连接。连接池可以帮助你管理连接的创建、复用和释放。Elasticsearch Java 客户端提供了连接池的支持，例如 Apache HttpAsyncClient 或 Netty。
设置重试策略：可以为 Java 客户端设置重试策略，以在连接失败时自动重试。重试策略可以根据需要进行配置，例如设置最大重试次数、重试间隔等。Elasticsearch Java 客户端提供了一些内置的重试策略，例如 RetryOnNetworkFailure 和 RetryWithBackoff。下面是

下面是一段实例：

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.RestClientBuilder.HttpClientConfigCallback;
import org.elasticsearch.client.RestClientBuilder.RequestConfigCallback;
import org.elasticsearch.client.RestClientBuilder.FailureListener;

import java.io.IOException;

public class ElasticsearchClientExample {
    public static void main(String[] args) {
        // 定义 Elasticsearch 集群的主机名和端口
        String[] hosts = { "host1:9200", "host2:9200", "host3:9200" };

        // 创建 RestClientBuilder，设置主机名和端口
        RestClientBuilder builder = RestClient.builder(getHttpHosts(hosts));

        // 设置连接池配置
        builder.setHttpClientConfigCallback(new HttpClientConfigCallback() {
            @Override
            public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
                return httpClientBuilder.setDefaultIOReactorConfig(IOReactorConfig.custom()
                        .setIoThreadCount(10)
                        .setConnectTimeout(5000)
                        .build());
            }
        });

        // 设置请求配置
        builder.setRequestConfigCallback(new RequestConfigCallback() {
            @Override
            public RequestConfig.Builder customizeRequestConfig(RequestConfig.Builder requestConfigBuilder) {
                return requestConfigBuilder.setSocketTimeout(30000);
            }
        });

        // 设置故障监听器
        builder.setFailureListener(new FailureListener() {
            @Override
            public void onFailure(HttpHost host) {
                System.out.println("Connection failed to host: " + host);
                // 在这里可以实现自定义的重试逻辑
            }
        });

        // 创建 RestHighLevelClient
        RestHighLevelClient client = new RestHighLevelClient(builder);

        // 使用 client 进行操作，如执行搜索、索引文档等
        // ...

        // 关闭 client
        try {
            client.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static HttpHost[] getHttpHosts(String[] hosts) {
        HttpHost[] httpHosts = new HttpHost[hosts.length];
        for (int i = 0; i < hosts.length; i++) {
            String[] parts = hosts[i].split(":");
            String hostname = parts[0];
            int port = Integer.parseInt(parts[1]);
            httpHosts[i] = new HttpHost(hostname, port, "http");
        }
        return httpHosts;
    }
}

在上述示例中，我们通过将主机名和端口传递给 RestClient.builder() 方法来创建 RestClientBuilder 对象。然后，我们使用 setHttpClientConfigCallback() 方法设置连接池的配置，使用 setRequestConfigCallback() 方法设置请求配置，以及使用 setFailureListener() 方法设置故障监听器。

解决方式4

使用监控节点健康状态：使用 Elasticsearch 提供的节点健康 API 或其他监控工具，定期检查节点的健康状态。如果一个节点被标记为不健康或下线，你可以更新 Java 客户端的连接配置，将其从可用节点列表中移除。

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.Request;
import org.elasticsearch.client.Response;
import org.elasticsearch.client.ResponseException;
import org.elasticsearch.client.RestClientBuilder.FailureListener;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class ElasticsearchClientExample {
    public static void main(String[] args) {
        // 定义 Elasticsearch 集群的主机名和端口
        String[] hosts = { "host1:9200", "host2:9200", "host3:9200" };

        // 创建 RestClientBuilder，设置主机名和端口
        RestClientBuilder builder = RestClient.builder(getHttpHosts(hosts));

        // 设置故障监听器
        builder.setFailureListener(new FailureListener() {
            @Override
            public void onFailure(HttpHost host) {
                System.out.println("Connection failed to host: " + host);
                // 在这里可以实现自定义的重试逻辑
                // 如果连接失败，可以将相应的节点标记为不健康或下线
            }
        });

        // 创建 RestHighLevelClient
        RestHighLevelClient client = new RestHighLevelClient(builder);

        // 定期检查节点健康状态
        checkNodeHealth(client, hosts);

        // 使用 client 进行操作，如执行搜索、索引文档等
        // ...

        // 关闭 client
        try {
            client.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static HttpHost[] getHttpHosts(String[] hosts) {
        HttpHost[] httpHosts = new HttpHost[hosts.length];
        for (int i = 0; i < hosts.length; i++) {
            String[] parts = hosts[i].split(":");
            String hostname = parts[0];
            int port = Integer.parseInt(parts[1]);
            httpHosts[i] = new HttpHost(hostname, port, "http");
        }
        return httpHosts;
    }

    private static void checkNodeHealth(RestHighLevelClient client, String[] hosts) {
        List<HttpHost> healthyNodes = new ArrayList<>();

        for (String host : hosts) {
            String[] parts = host.split(":");
            String hostname = parts[0];
            int port = Integer.parseInt(parts[1]);

            HttpHost httpHost = new HttpHost(hostname, port, "http");
            Request request = new Request("GET", "/_cluster/health");

            try {
                Response response = client.getLowLevelClient().performRequest(request);
                int statusCode = response.getStatusLine().getStatusCode();

                if (statusCode == 200) {
                    // 节点健康
                    healthyNodes.add(httpHost);
                }
            } catch (ResponseException e) {
                // 节点不健康或下线
                System.out.println("Node " + httpHost + " is unhealthy or offline.");
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // 更新连接配置，将健康的节点添加到可用节点列表中
        RestClientBuilder builder = RestClient.builder(healthyNodes.toArray(new HttpHost[0]));

        // 设置故障监听器
        builder.setFailureListener(new FailureListener() {
            @Override
            public void onFailure(HttpHost host) {
                System.out.println("Connection failed to host: " + host);
                // 在这里可以实现自定义的重试逻辑
                // 如果连接失败，可以将相应的节点标记为不健康或下线
            }
        });

        // 创建新的 RestHighLevelClient
        RestHighLevelClient newClient = new RestHighLevelClient(builder);

        // 使用新的 client 进行操作，如执行搜索、索引文档等
        // ...

        // 关闭新的 client
        try {
            newClient.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上述示例中，定义了一个 checkNodeHealth() 方法，该方法使用 RestHighLevelClient 对每个节点发送一个健康检查请求。如果节点返回状态码为 200，则被视为健康节点，并将其添加到 healthyNodes 列表中。如果请求失败或返回其他状态码，则被视为不健康或下线的节点。

然后，使用 healthyNodes 列表中的节点创建一个新的 RestClientBuilder 对象，并设置相应的故障监听器。最后，我们使用新的 RestHighLevelClient 对象进行操作。