Spring Boot 整合 elasticsearch-rest-high-level-client

注意：本篇博客风格（不多比比就是撸代码!!!）

一、maven依赖

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

二、EsConfig.java

import lombok.extern.slf4j.Slf4j;
import org.apache.http.Header;
import org.apache.http.HttpHost;
import org.apache.http.client.config.RequestConfig;
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;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author Andon
 * 2021/3/10
 */
@Slf4j
@Configuration
public class EsConfig {

    @Value("${elasticsearch.uris}")
    public String uris;

    @Bean
    public RestHighLevelClient getHighClient() {
        return new RestHighLevelClient(getClientBuilder());
    }

    private RestClientBuilder getClientBuilder() {
        // 如果有多个从节点可以持续在内部new多个HttpHost，参数1是ip,参数2是HTTP端口，参数3是通信协议
        String[] urisArr = uris.split(",");
        HttpHost[] httpHosts = new HttpHost[urisArr.length];
        for (int i = 0; i < urisArr.length; i++) {
//            String[] hostNamePort = urisArr[i].split(":");
//            HttpHost http = new HttpHost(hostNamePort[0], Integer.parseInt(hostNamePort[1]), "http");
//            httpHosts[i] = http;
            httpHosts[i] = HttpHost.create(urisArr[i]);
        }
        RestClientBuilder clientBuilder = RestClient.builder(httpHosts);

        // 添加其他配置，返回来的还是RestClientBuilder对象，这些配置都是可选的
        // clientBuilder.setXX()...

        // 设置请求头，每个请求都会带上这个请求头
        Header[] defaultHeaders = {new BasicHeader("header", "value")};
        clientBuilder.setDefaultHeaders(defaultHeaders);

        // 设置监听器，每次节点失败都可以监听到，可以作额外处理
        clientBuilder.setFailureListener(new RestClient.FailureListener() {
            @Override
            public void onFailure(Node node) {
                super.onFailure(node);
                log.error(node.getName() + "==节点失败了");
            }
        });

        /* 配置异步请求的线程数量，Apache Http Async Client默认启动一个调度程序线程，以及由连接管理器使用的许多工作线程
        （与本地检测到的处理器数量一样多，取决于Runtime.getRuntime().availableProcessors()返回的数量）。线程数可以修改如下,
        这里是修改为1个线程，即默认情况
        */
        clientBuilder.setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
            @Override
            public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpAsyncClientBuilder) {
                return httpAsyncClientBuilder.setDefaultIOReactorConfig(
                        IOReactorConfig.custom().setIoThreadCount(1).build()
                );
            }
        });

        /*
        配置请求超时，将连接超时（默认为1秒）和套接字超时（默认为30秒）增加，
        这里配置完应该相应地调整最大重试超时（默认为30秒），即上面的setMaxRetryTimeoutMillis，一般于最大的那个值一致即60000
        */
        clientBuilder.setRequestConfigCallback(new RestClientBuilder.RequestConfigCallback() {
            @Override
            public RequestConfig.Builder customizeRequestConfig(RequestConfig.Builder requestConfigBuilder) {
                // 连接5秒超时，套接字连接60s超时
                return requestConfigBuilder.setConnectTimeout(5000).setSocketTimeout(60000);
            }
        });

        //配置ES安全认证
        //如果ES设置了密码，那这里也提供了一个基本的认证机制，下面设置了ES需要基本身份验证的默认凭据提供程序
//        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
//        credentialsProvider.setCredentials(AuthScope.ANY,
//                new UsernamePasswordCredentials("user", "password"));
//        clientBuilder.setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
//            @Override
//            public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
//                return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
//            }
//        });

        //上面采用异步机制实现抢先认证，这个功能也可以禁用，这意味着每个请求都将在没有授权标头的情况下发送，然后查看它是否被接受，
        //并且在收到HTTP 401响应后，它再使用基本认证头重新发送完全相同的请求，这个可能是基于安全、性能的考虑
//        clientBuilder.setHttpClientConfigCallback(new RestClientBuilder.HttpClientConfigCallback() {
//            @Override
//            public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
//                // 禁用抢先认证的方式
//                httpClientBuilder.disableAuthCaching();
//                return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
//            }
//        });

        // 最后配置好的clientBuilder再build一下即可得到真正的Client
        return clientBuilder;
    }
}

三、EsService.java

import com.alibaba.fastjson.JSONObject;
import com.andon.common.model.BaseModelES;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.xcontent.XContentType;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.io.IOException;
import java.util.List;

/**
 * @author Andon
 * 2021/3/10
 */
@Slf4j
@Service
public class EsService {

    @Resource
    private RestHighLevelClient client;

    private static final String TYPE = "_doc";

    /**
     * add
     */
    public <T extends BaseModelES> void add(String indexName, T baseModelES) {
        try {
            IndexRequest indexRequest = new IndexRequest(indexName);
            indexRequest.id(baseModelES.getId());
            indexRequest.source(JSONObject.toJSONString(baseModelES), XContentType.JSON);
            client.index(indexRequest, RequestOptions.DEFAULT);
        } catch (IOException e) {
            log.error("add failure!! error={}", e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * addBulk
     */
    public <T extends BaseModelES> void addBulk(String indexName, List<T> baseModelESList) {
        try {
            BulkRequest bulkRequest = new BulkRequest();
            for (BaseModelES baseModelES : baseModelESList) {
                IndexRequest indexRequest = new IndexRequest(indexName);
                indexRequest.id(baseModelES.getId());
                indexRequest.source(JSONObject.toJSONString(baseModelES), XContentType.JSON);
                bulkRequest.add(indexRequest);
            }
            client.bulk(bulkRequest, RequestOptions.DEFAULT);
        } catch (IOException e) {
            log.error("addBulk failure!! error={}", e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * deleteById
     */
    public void deleteById(String indexName, String id) {
        try {
            DeleteRequest deleteRequest = new DeleteRequest(indexName);
            deleteRequest.id(id);
            client.delete(deleteRequest, RequestOptions.DEFAULT);
        } catch (IOException e) {
            log.error("deleteById failure!! error={}", e.getMessage());
            e.printStackTrace();
        }
    }

	/**
     * deleteBulk
     */
    public <T extends BaseModelES> void deleteBulk(String indexName, List<T> baseModelESList) {
        try {
            BulkRequest bulkRequest = new BulkRequest();
            for (BaseModelES baseModelES : baseModelESList) {
                DeleteRequest deleteRequest = new DeleteRequest(indexName);
                deleteRequest.id(baseModelES.getId());
                bulkRequest.add(deleteRequest);
            }
            client.bulk(bulkRequest, RequestOptions.DEFAULT);
            log.info("deleteBulk success!! indexName:{} baseModelESList.size={}", indexName, baseModelESList.size());
        } catch (IOException e) {
            log.error("deleteBulk failure!! error={}", e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * update
     */
    public <T extends BaseModelES> void update(String indexName, T baseModelES) {
        try {
            UpdateRequest updateRequest = new UpdateRequest(indexName, baseModelES.getId());
            IndexRequest indexRequest = new IndexRequest(indexName);
            indexRequest.id(baseModelES.getId());
            indexRequest.source(JSONObject.toJSONString(baseModelES), XContentType.JSON);
            updateRequest.doc(indexRequest);
            client.update(updateRequest, RequestOptions.DEFAULT);
        } catch (IOException e) {
            log.error("update failure!! error={}", e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * getById
     */
    public GetResponse getById(String indexName, String id) {
        try {
            GetRequest getRequest = new GetRequest(indexName, id);
            return client.get(getRequest, RequestOptions.DEFAULT);
        } catch (IOException e) {
            log.error("getById failure!! error={}", e.getMessage());
            e.printStackTrace();
            return null;
        }
    }

    /**
     * queryBySearchRequest
     */
    public SearchResponse queryBySearchRequest(String indexName, SearchSourceBuilder sourceBuilder) {
        try {
            // 创建并设置SearchRequest对象
            SearchRequest searchRequest = new SearchRequest();
            // 设置request要搜索的索引
            searchRequest.indices(indexName);
            // 设置SearchSourceBuilder查询属性
            searchRequest.source(sourceBuilder);
            // 查询
            return client.search(searchRequest, RequestOptions.DEFAULT);
        } catch (IOException e) {
            log.error("queryBySearchRequest failure!! error={}", e.getMessage());
            e.printStackTrace();
            return null;
        }
    }
}

四、BaseModelES.java

import java.io.Serializable;

/**
 * @author Andon
 * 2021/3/9
 */
public abstract class BaseModelES implements Serializable {

    public abstract String getId();
}

五、TestEs.java

import org.springframework.util.ObjectUtils;

/**
 * @author Andon
 * 2021/3/9
 */
public class TestEs extends BaseModelES {

    private String id;
    private String key;
    private String value;
    private String time;

    public void setId(String id) {
        this.id = id;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public String getTime() {
        return time;
    }

    public void setTime(String time) {
        this.time = time;
    }

    @Override
    public String getId() {
        if (!ObjectUtils.isEmpty(id)) {
            return id;
        }
        return key + "_" + time;
    }
}

六、测试

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.andon.common.model.TestEs;
import com.andon.controller.service.EsService;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.index.query.BoolQueryBuilder;
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.sort.SortOrder;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;

/**
 * @author Andon
 * 2021/3/10
 */
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest
public class EsServiceTest {

    @Resource
    private EsService esService;

    @Test
    public void test01() {
        List<TestEs> testEsList = new ArrayList<>();
        String indexName = "test";
        // 创建并设置SearchSourceBuilder对象
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        // 创建BoolQueryBuilder对象
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        // must-termQuery (类似于sql语句中的AND)
        boolQueryBuilder.must(QueryBuilders.termQuery("key", "Java"));
        // filter-termsQuery (类似于sql语句中的IN)
        boolQueryBuilder.filter(QueryBuilders.termsQuery("key", "Java,Elastic,mysql".split(",")));
        // must-range (gte类似于sql语句中的>=)
        boolQueryBuilder.must(QueryBuilders.rangeQuery("time").gte("2021-03-10 09:40:20"));
        sourceBuilder.query(boolQueryBuilder);
        // sort (类似于sql语句中的ORDER BY,倒叙SortOrder.DESC)
        sourceBuilder.sort("time", SortOrder.DESC);
        // from-size (类似于sql语句中的LIMIT)
        sourceBuilder.from(0).size(5);
        // 正确的显示总记录数
        searchSourceBuilder.trackTotalHits(true);
        // 查询
        SearchResponse searchResponse = esService.queryBySearchRequest(indexName, sourceBuilder);
        SearchHits hits = searchResponse.getHits();
        SearchHit[] hitsArr = hits.getHits();
        for (SearchHit documentFields : hitsArr) {
            TestEs testEs = JSONObject.parseObject(documentFields.getSourceAsString(), new TypeReference<TestEs>() {
            }.getType());
            testEsList.add(testEs);
        }
        log.info("testEsList:{}", JSONObject.toJSONString(testEsList));
    }
}