es（7.6.1版本）创建客户端及连接使用

一、初始化es客户端

package com.zh.jg.es;

import org.apache.http.Header;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.apache.http.impl.nio.reactor.IOReactorConfig;
import org.apache.http.message.BasicHeader;
import org.elasticsearch.client.Node;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;

/**
 * <h3>sjzt-common</h3>
 * <p></p>
 *
 * @author :
 * @date : 2020-05-11 16:23
 **/
public class ClientBuilders {
    private static final String CLUSTER_HOSTNAME_PORT = "hostIp:port";

    public static void main(String[] args) {
        getClientBulider();
    }
    /**
     * 初始化 clientBuilder的详细说明
     * @return
     */
    public static RestClientBuilder getClientBulider() {


        String [] hostNamesPort = CLUSTER_HOSTNAME_PORT.split(",");

        String host;
        int port;
        String[] temp;

        RestClientBuilder restClientBuilder = null;

        /*restClient 初始化*/
        if (0 != hostNamesPort.length) {
            for (String hostPort : hostNamesPort) {
                temp = hostPort.split(":");
                host = temp[0].trim();
                port = Integer.parseInt(temp[1].trim());
                restClientBuilder = RestClient.builder(new HttpHost(host, port, "http"));
            }
        }

        /*RestClientBuilder 在构建 RestClient 实例时可以设置以下的可选配置参数*/

        /*1.设置请求头，避免每个请求都必须指定*/
        Header[] defaultHeaders = new Header[]{
                new BasicHeader("header", "value")
        };
        restClientBuilder.setDefaultHeaders(defaultHeaders);

        /*2.设置在同一请求进行多次尝试时应该遵守的超时时间。默认值为30秒，与默认`socket`超时相同。
            如果自定义设置了`socket`超时，则应该相应地调整最大重试超时。*/


        /*3.设置每次节点发生故障时收到通知的侦听器。内部嗅探到故障时被启用。*/
        restClientBuilder.setFailureListener(new RestClient.FailureListener() {

            public void onFailure(Node node) {
                super.onFailure(node);
            }
        });

        /*4.设置修改默认请求配置的回调（例如：请求超时，认证，或者其他
         设置）。
         */
        restClientBuilder.setRequestConfigCallback(new RestClientBuilder.RequestConfigCallback() {


            public RequestConfig.Builder customizeRequestConfig(RequestConfig.Builder requestConfigBuilder) {
                return requestConfigBuilder.setSocketTimeout(10000);
            }
        });

        /*5.//设置修改 http 客户端配置的回调（例如：ssl 加密通讯，线程IO的配置，或其他任何         设置）*/


        // 简单的身份认证
        final CredentialsProvider credentialsProvider =
                new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials("elastic", "elaser"));


        restClientBuilder.setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {

            public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpAsyncClientBuilder) {
                httpAsyncClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
                //线程设置
                httpAsyncClientBuilder.setDefaultIOReactorConfig(IOReactorConfig.custom().setIoThreadCount(10).build());
                return httpAsyncClientBuilder;
            }
        });

        return restClientBuilder;
    }
}

二、创建es客户端

package com.zh.jg.es;

import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.sniff.Sniffer;

import java.io.IOException;

/**
 * <h3>sjzt-common</h3>
 * <p></p>
 *
 * @author : 
 * @date : 2020-05-11 16:29
 **/
public class HighLevelClient {
    private static RestClientBuilder restClientBuilder = ClientBuilders.getClientBulider();

    // 实例化客户端
    private static RestHighLevelClient restHighLevelClient;
    // 嗅探器实例化
    private static Sniffer sniffer;

    /**
     * 开启client，sniffer
     * @return
     */
    public RestHighLevelClient getClient() {
        restHighLevelClient = new RestHighLevelClient(restClientBuilder);
        //十秒刷新并更新一次节点
        sniffer = Sniffer.builder(restHighLevelClient.getLowLevelClient())
                .setSniffAfterFailureDelayMillis(10000)
                .build();

        return restHighLevelClient;
    }

    /**
     *
     * 关闭sniffer client
     */
    public void closeRestHighLevelClient() {
        if (null != restHighLevelClient) {
            try {
                sniffer.close();
                restHighLevelClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

三、es客户端的增删改查

package com.zh.jg.es;

import com.alibaba.fastjson.JSONObject;
import org.elasticsearch.action.ActionListener;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteResponse;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.unit.TimeValue;
import org.elasticsearch.common.xcontent.XContentType;

import java.io.IOException;
import java.util.Map;

public class EsUtil {
    // 生成批量处理对象
   private static BulkRequest bulkRequest = new BulkRequest();

    /**
     * 添加数据到es
     * @param indexName
     * @param typeName
     * @param indexId
     * @param json
     */

    public static void add(RestHighLevelClient restHighLevelClient, String indexName, String typeName, String indexId, Map<String, Object> json) throws IOException {
        IndexRequest indexRequest = new IndexRequest(indexName, typeName,indexId);
        indexRequest.source(new JSONObject(json).toString(), XContentType.JSON);
        try {
            restHighLevelClient.index(indexRequest,RequestOptions.DEFAULT);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /**
     * 判断索引名是否存在
     * @param indexName
     * @return
     */
    public static boolean existsIndex(RestHighLevelClient restHighLevelClient,String indexName) {
        try{
            GetIndexRequest request = new GetIndexRequest(indexName);
            boolean exists = restHighLevelClient.indices().exists(request, RequestOptions.DEFAULT);
            return exists;
        }catch (Exception e){
            System.out.println("Exception");
        }
        return false;
    }
    /**
     * @param : client
     * @description : 判断文档是否存在
     */
    public static boolean isExist(RestHighLevelClient restHighLevelClient, String indexName, String typeName, String indexId) throws IOException{

        GetRequest request = new GetRequest(indexName, typeName, indexId);
        //1.同步判断
        boolean exists = restHighLevelClient.exists(request, RequestOptions.DEFAULT);

        //2.异步判断
        ActionListener<Boolean> listener = new ActionListener<Boolean>() {
            @Override
            public void onResponse(Boolean exists) {
                if (exists){
                    System.out.println("文档存在");
                }else {
                    System.out.println("文档不存在");
                }
            }

            @Override
            public void onFailure(Exception e) {

            }
        };
        //client.existsAsync(request, RequestOptions.DEFAULT, listener);

        return exists;
    }

    /**
     * @param : client
     * @description : 删除文档
     */
    public static void deleteDocument(RestHighLevelClient restHighLevelClient, String indexName, String typeName, String indexId) throws IOException{

        DeleteRequest request = new DeleteRequest(indexName,typeName,indexId);

        //设置请求超时时间：2分钟
        request.timeout(TimeValue.timeValueMinutes(2));
        //request.timeout("2m");

        //同步删除
        DeleteResponse deleteResponse = restHighLevelClient.delete(request, RequestOptions.DEFAULT);

        //异步删除
        ActionListener<DeleteResponse> listener = new ActionListener<DeleteResponse>() {
            @Override
            public void onResponse(DeleteResponse deleteResponse) {
                System.out.println("删除后操作");
            }

            @Override
            public void onFailure(Exception e) {
                System.out.println("删除失败");
            }
        };

    }

    /**
     * 批量增加数据的方法
     * @param restHighLevelClient
     * @param indexname
     * @param typename
     * @param row_key
     * @param map
     * @throws Exception
     */
    public void bulkadd(RestHighLevelClient restHighLevelClient, String indexname, String typename, String row_key, Map<String,Object> map) throws Exception {

        try {
            // 生成批量处理对象
            //BulkRequest bulkRequest = new BulkRequest();

            // 得到某一行的数据,并封装成索引对象
            IndexRequest indexRequest = new IndexRequest(indexname, typename,row_key);
            indexRequest.source(new JSONObject(map).toString(), XContentType.JSON);


            //判断是否执行加载
            if (bulkRequest.numberOfActions() != 0 && (bulkRequest.numberOfActions() > 100)) {
                try {
                    bulkRequest(restHighLevelClient);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            // 装填数据
            bulkRequest.add(indexRequest);

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            bulkRequest(restHighLevelClient);
        }
    }

    /**
     * 批量具体执行方法
     * execute bulk process
     * @throws Exception
     */
    private void bulkRequest(RestHighLevelClient restHighLevelClient) throws Exception {
        // 加载数据
        BulkResponse bulkResponse = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);

        // 判断加载情况
        if(bulkResponse.hasFailures()){
            System.out.println("失败");
        }else{
            System.out.println("成功");
            // 重新定义
            bulkRequest = new BulkRequest();

        }
    }

}