开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 大数据 -> Elasticsearch-03-JavaApi以及springboot中操作-RestHighLevelClient -> 正文阅读

[大数据]Elasticsearch-03-JavaApi以及springboot中操作-RestHighLevelClient

前言

Elasticsearch 软件是由 Java 语言开发的，所以也可以通过 JavaAPI 的方式对 Elasticsearch
服务进行访问
之前是对ES中的创建/查看/删除索引、创建定义映射、创建/查看/修改/删除文档的这些操作有了一定的了解认识，但是是通过Postman + JSON串的方法来实现的

那么之后仍然是对ES中的索引、映射、文档进行操作，只是方法换成了Java API。

一：导包

<dependencies>
        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>7.8.0</version>
        </dependency>
        <!-- elasticsearch 的客户端 -->
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.8.0</version>
        </dependency>
        <!-- elasticsearch 依赖 2.x 的 log4j -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>2.8.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.8.2</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.9</version>
        </dependency>
        <!-- junit 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
         <!--lombok依赖-->
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
    </dependencies>

二：客户端对象

创建 com.atguigu.es.test.Elasticsearch01_Client 类，代码中创建 Elasticsearch 客户端对象
因为早期版本的客户端对象已经不再推荐使用，且在未来版本中会被删除，所以这里我们采
用高级 REST 客户端对象-RestHighLevelClient

package es;

import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;

import java.io.IOException;

/** 创建es客户端
 * @author wkl
 * @create 2022-06-28 14:56
 */
public class EsClient {
    public static void main(String[] args) throws IOException {
        //创建ES客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http"))
        );

        //关闭ES客户端
        esClient.close();
    }
}

三：客户端操作

1:索引操作

1：创建索引


/** 索引类操作
 * @author wkl
 * @create 2022-06-28 15:04
 */
public class CreateIndex {
    public static void main(String[] args) throws IOException {
        //创建ES客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http"))
        );

        //创建索引对象
        CreateIndexRequest createIndexRequest = new CreateIndexRequest("user");

        //发送请求
        CreateIndexResponse createIndexResponse = esClient.indices().create(createIndexRequest, RequestOptions.DEFAULT);

        boolean acknowledged = createIndexResponse.isAcknowledged();
        System.out.println("索引操作："+acknowledged);

        //关闭ES客户端
        esClient.close();
    }
}

2：查看索引

/**
 * @author wkl
 * @create 2022-06-28 15:15
 */
public class GerIndex {
    public static void main(String[] args) throws IOException {
        //创建ES客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http"))
        );

        GetIndexRequest request = new GetIndexRequest("user");

        GetIndexResponse getIndexResponse = esClient.indices().get(request, RequestOptions.DEFAULT);

        System.out.println(getIndexResponse.getAliases());
        System.out.println(getIndexResponse.getMappings());
        System.out.println(getIndexResponse.getDataStreams());
        System.out.println(getIndexResponse.getSettings());

        //关闭ES客户端
        esClient.close();
    }
}

3：删除索引


/**
 * @author wkl
 * @create 2022-06-28 15:20
 */
public class DeleteIndex {
    public static void main(String[] args) throws IOException {
        //创建ES客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http"))
        );

        DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("student");

        AcknowledgedResponse delete = esClient.indices().delete(deleteIndexRequest, RequestOptions.DEFAULT);

        System.out.println(delete.isAcknowledged());

        //关闭ES客户端
        esClient.close();
    }
}

2：文档操作

1：创建文档

1：创建实体-我这里使用了lombok代替get,set,这个就不介绍了哈
/**

@author wkl
@create 2022-06-28 15:24
*/
@Data
public class User {
private String name;
private String sex;
private int age;
}
2：创建文档

/**
 * @author wkl
 * @create 2022-06-28 15:25
 */
public class CreateDocument {

    public static void main(String[] args) throws IOException {
        //创建ES客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http"))
        );

        //创建文档对象
        IndexRequest indexRequest = new IndexRequest();
        //设置索引及索引中文档的唯一性标识id（如果不指定，则ES会默认随机生成一个id，建议指定id值，也是为了后续查找方便）
        indexRequest.index("user").id("1");

        //创建数据对象
        User user = new User();
        user.setName("张三");
        user.setSex("男");
        user.setAge(35);
        user.setBir(new Date());

        //向es中插入数据，此数据必须是json格式，并且es在后台动态创建映射
        indexRequest.source(JSONObject.toJSONString(user), XContentType.JSON);

        //发送请求
        IndexResponse index = esClient.index(indexRequest, RequestOptions.DEFAULT);
        System.out.println(index.getId());
        System.out.println(index.getIndex());
        System.out.println(index.getResult());


        //关闭ES客户端
        esClient.close();
    }

}

2：查询文档


/**
 * @author wkl
 * @create 2022-06-28 16:02
 */
public class UpdateDocument {
    public static void main(String[] args) throws IOException {
        //创建ES客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http"))
        );

        UpdateRequest updateRequest = new UpdateRequest();
        updateRequest.index("user").id("1");

        //将修改后的内容，以JSON格式写入请求体中
        updateRequest.doc(XContentType.JSON,"age",26);
        

        //发送请求 --- 获取响应
        UpdateResponse update = esClient.update(updateRequest, RequestOptions.DEFAULT);
        System.out.println(update.getResult());

        //关闭ES客户端
        esClient.close();
    }
}

3：删除文档


/**
 * @author wkl
 * @create 2022-06-28 16:07
 */
public class DeleteDoucument {
    public static void main(String[] args) throws IOException {
        //创建ES客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http"))
        );

        //创建删除文档请求
        DeleteRequest deleteRequest = new DeleteRequest();

        //设置删除id
        deleteRequest.index("user").id("1");

        //发送请求
        DeleteResponse delete = esClient.delete(deleteRequest, RequestOptions.DEFAULT);
        System.out.println(delete.getResult());


        //关闭ES客户端
        esClient.close();
    }
}

4：批量新增


public class BatchCreateDocument {
    public static void main(String[] args) throws IOException {
        //创建ES客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http"))
        );

        //创建请求对象
        BulkRequest bulkRequest = new BulkRequest();

        //设置请求参数
        bulkRequest.add(new IndexRequest().index("user").id("2").source(JSONObject.toJSONString(new User("李四","男",20,new Date())), XContentType.JSON));
        bulkRequest.add(new IndexRequest().index("user").id("3").source(JSONObject.toJSONString(new User("小花","女",18,new Date())), XContentType.JSON));
        bulkRequest.add(new IndexRequest().index("user").id("4").source(JSONObject.toJSONString(new User("小雪","女",24,new Date())), XContentType.JSON));

        //发送请求
        BulkResponse bulk = esClient.bulk(bulkRequest, RequestOptions.DEFAULT);
        System.out.println(bulk.getTook());


        //关闭ES客户端
        esClient.close();
    }
}

5：批量删除


/**
 * @author wkl
 * @create 2022-06-28 16:12
 */
public class BatchDleteDocument {
    public static void main(String[] args) throws IOException {
        //创建ES客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http"))
        );

        //创建请求对象
        BulkRequest bulkRequest = new BulkRequest();

        //设置请求参数
        bulkRequest.add(new DeleteRequest().index("user").id("1"));
        bulkRequest.add(new DeleteRequest().index("user").id("2"));

        //发送请求
        BulkResponse bulk = esClient.bulk(bulkRequest, RequestOptions.DEFAULT);
        System.out.println(bulk.getItems());


        //关闭ES客户端
        esClient.close();
    }
}

3：高级查询

1：全量查询

/**
 * @author wkl
 * @create 2022-06-28 16:29
 */
public class Match_allQuery {

    public static void main(String[] args) throws IOException {
        //创建ES客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http"))
        );

        //创建搜索对象
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");

        //构建查询的请求体

        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //查询所有数据
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());

        searchRequest.source(searchSourceBuilder);

        //发送请求
        SearchResponse search = esClient.search(searchRequest, RequestOptions.DEFAULT);

        //分析结果
        SearchHits hits = search.getHits();
        for (SearchHit hit : hits) {

            System.out.println(hit.getSourceAsString());
        }


        //关闭ES客户端
        esClient.close();
    }
}

2：条件查询-term 查询，查询条件为关键字


/**
 * @author wkl
 * @create 2022-06-28 17:53
 */
public class TermQuery {
    public static void main(String[] args) throws IOException {
        //创建ES客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http"))
        );

        //创建搜索对象
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");

        //构建请求体
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //查询数据
        searchSourceBuilder.query(QueryBuilders.termQuery("age",20));
        searchRequest.source(searchSourceBuilder);

        //发送请求
        SearchResponse search = esClient.search(searchRequest, RequestOptions.DEFAULT);

        //解析结果
        SearchHits hits = search.getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }

        //关闭ES客户端
        esClient.close();
    }
}

在这里插入图片描述

3：分词查询-match

/**
 * @author wkl
 * @create 2022-06-28 17:53
 */
public class MatchQuery {
    public static void main(String[] args) throws IOException {
        //创建ES客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http"))
        );

        //创建搜索对象
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");

        //构建请求体
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //查询数据
        searchSourceBuilder.query(QueryBuilders.matchQuery("name","小"));
        searchRequest.source(searchSourceBuilder);

        //发送请求
        SearchResponse search = esClient.search(searchRequest, RequestOptions.DEFAULT);

        //解析结果
        SearchHits hits = search.getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }

        //关闭ES客户端
        esClient.close();
    }
}

在这里插入图片描述

4：分页查询-from&size


/**
 * @author wkl
 * @create 2022-06-28 17:53
 */
public class MatchOfpageQuery {
    public static void main(String[] args) throws IOException {
        //创建ES客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http"))
        );

        //创建搜索对象
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");

        //构建请求体
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //查询数据
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());
        // 分页查询
        // 当前页其实索引 (第一条数据的顺序号)，from
        searchSourceBuilder.from(0);
        searchSourceBuilder.size(2);

        searchRequest.source(searchSourceBuilder);

        //发送请求
        SearchResponse search = esClient.search(searchRequest, RequestOptions.DEFAULT);

        //解析结果
        SearchHits hits = search.getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }

        //关闭ES客户端
        esClient.close();
    }
}

5：数据排序-sort


/**
 * @author wkl
 * @create 2022-06-28 17:53
 */
public class SortQuery {
    public static void main(String[] args) throws IOException {
        //创建ES客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http"))
        );

        //创建搜索对象
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");

        //构建请求体
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //查询数据
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());
        //排序
        searchSourceBuilder.sort("age", SortOrder.DESC);

        searchRequest.source(searchSourceBuilder);

        //发送请求
        SearchResponse search = esClient.search(searchRequest, RequestOptions.DEFAULT);

        //解析结果
        SearchHits hits = search.getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }

        //关闭ES客户端
        esClient.close();
    }
}

6：过滤字段-fetch


/**
 * @author wkl
 * @create 2022-06-28 17:53
 */
public class FilterQuery {
    public static void main(String[] args) throws IOException {
        //创建ES客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http"))
        );

        //创建搜索对象
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");

        //构建请求体
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //查询数据
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());
        //过滤查询
        //排除字段
        String[] excludes = {};
        //包含字段
        String[] includes = {"age","sex"};
        searchSourceBuilder.fetchSource(includes,excludes);

        searchRequest.source(searchSourceBuilder);

        //发送请求
        SearchResponse search = esClient.search(searchRequest, RequestOptions.DEFAULT);

        //解析结果
        SearchHits hits = search.getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }

        //关闭ES客户端
        esClient.close();
    }
}

7：Bool查询-bool


/**
 * @author wkl
 * @create 2022-06-28 17:53
 */
public class BoolQuery {
    public static void main(String[] args) throws IOException {
        //创建ES客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http"))
        );

        //创建搜索对象
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");

        //构建请求体
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //查询数据

        //构建bool选择器
        BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();
        // 必须包含
        boolQueryBuilder.must (QueryBuilders.matchQuery("age", "18"));
        // 一定不含
        boolQueryBuilder.mustNot (QueryBuilders.matchQuery("name", "zhangsan"));
        // 可能包含
        boolQueryBuilder.should (QueryBuilders.matchQuery("sex", "女"));

        //将bool选择器假如到请求体重
        searchSourceBuilder.query(boolQueryBuilder);


        searchRequest.source(searchSourceBuilder);

        //发送请求
        SearchResponse search = esClient.search(searchRequest, RequestOptions.DEFAULT);

        //解析结果
        SearchHits hits = search.getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }

        //关闭ES客户端
        esClient.close();
    }
}

8：范围查询-range


/**
 * @author wkl
 * @create 2022-06-28 17:53
 */
public class RangQuery {
    public static void main(String[] args) throws IOException {
        //创建ES客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http"))
        );

        //创建搜索对象
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");

        //构建请求体
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //查询数据
        RangeQueryBuilder rangeQueryBuilder = new RangeQueryBuilder("age");
        rangeQueryBuilder.gte(18);
        rangeQueryBuilder.lte(30);

        //将bool选择器假如到请求体重
        searchSourceBuilder.query(rangeQueryBuilder);


        searchRequest.source(searchSourceBuilder);

        //发送请求
        SearchResponse search = esClient.search(searchRequest, RequestOptions.DEFAULT);

        //解析结果
        SearchHits hits = search.getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }

        //关闭ES客户端
        esClient.close();
    }
}

9：模糊查询-fuzzi

/**
 * @author wkl
 * @create 2022-06-28 17:53
 */
public class FuzzinQuery {
    public static void main(String[] args) throws IOException {
        //创建ES客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http"))
        );

        //创建搜索对象
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");

        //构建请求体
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //查询数据
        FuzzyQueryBuilder fuzzyQueryBuilder = QueryBuilders.fuzzyQuery("name", "小");

        searchSourceBuilder.query(fuzzyQueryBuilder.fuzziness(Fuzziness.ONE));

        searchRequest.source(searchSourceBuilder);


        //发送请求
        SearchResponse search = esClient.search(searchRequest, RequestOptions.DEFAULT);

        //解析结果
        SearchHits hits = search.getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }

        //关闭ES客户端
        esClient.close();
    }
}

10：聚合查询


/**
 * @author wkl
 * @create 2022-06-28 17:53
 */
public class AggrQuery {
    public static void main(String[] args) throws IOException {
        //创建ES客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http"))
        );

        //创建搜索对象
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");

        //构建请求体
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //查询数据
        searchSourceBuilder.aggregation(AggregationBuilders.max("max_value").field("age"));

        searchRequest.source(searchSourceBuilder);

        //发送请求
        SearchResponse search = esClient.search(searchRequest, RequestOptions.DEFAULT);

        //解析结果
        SearchHits hits = search.getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }

        //关闭ES客户端
        esClient.close();
    }
}

11：分组查询


/**
 * @author wkl
 * @create 2022-06-28 17:53
 */
public class AggrGroupQuery {
    public static void main(String[] args) throws IOException {
        //创建ES客户端
        RestHighLevelClient esClient = new RestHighLevelClient(
                RestClient.builder(new HttpHost("localhost",9200,"http"))
        );

        //创建搜索对象
        SearchRequest searchRequest = new SearchRequest();
        searchRequest.indices("user");

        //构建请求体
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //查询数据
        searchSourceBuilder.aggregation(AggregationBuilders.terms("group_value").field("age"));

        searchRequest.source(searchSourceBuilder);

        //发送请求
        SearchResponse search = esClient.search(searchRequest, RequestOptions.DEFAULT);

        //解析结果
        SearchHits hits = search.getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }

        //关闭ES客户端
        esClient.close();
    }
}

四：springboot中使用HighLevelClient 操作es

上述利用的是javase程序来进行测试的，但是我们现在环境基本都是springboot，实际上springboot环境下使用和上边是一样的，就是client客户端采用依赖注入的方式；

1：导包

<dependencies>
        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>7.8.0</version>
        </dependency>
        <!-- elasticsearch 的客户端 -->
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>elasticsearch-rest-high-level-client</artifactId>
            <version>7.8.0</version>
        </dependency>
        <!-- elasticsearch 依赖 2.x 的 log4j -->
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>2.8.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.8.2</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.9.9</version>
        </dependency>
        <!-- junit 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
         <!--lombok依赖-->
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
    </dependencies>

2：配置config,链接es

package es.config;

import java.util.ArrayList;
import org.apache.http.HttpHost;
import org.apache.http.client.config.RequestConfig.Builder;
import org.apache.http.impl.nio.client.HttpAsyncClientBuilder;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestClientBuilder;
import org.elasticsearch.client.RestClientBuilder.HttpClientConfigCallback;
import org.elasticsearch.client.RestClientBuilder.RequestConfigCallback;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author wkl
 * @create 2022-06-28 18:46
 */
@Configuration
public class EsConfiguration {
    private static String hosts = "192.168.62.145"; // 集群地址，多个用,隔开
    private static int port = 9200; // 使用的端口号
    private static String schema = "http"; // 使用的协议
    private static ArrayList<HttpHost> hostList = null;

    private static int connectTimeOut = 1000; // 连接超时时间
    private static int socketTimeOut = 30000; // 连接超时时间
    private static int connectionRequestTimeOut = 500; // 获取连接的超时时间

    private static int maxConnectNum = 100; // 最大连接数
    private static int maxConnectPerRoute = 100; // 最大路由连接数

    private RestClientBuilder builder;

    static {
        hostList = new ArrayList<>();
        String[] hostStrs = hosts.split(",");
        for (String host : hostStrs) {
            hostList.add(new HttpHost(host, port, schema));
        }
    }

    @Bean
    public RestHighLevelClient client() {
        builder = RestClient.builder(hostList.toArray(new HttpHost[0]));
        setConnectTimeOutConfig();
        setMutiConnectConfig();
        RestHighLevelClient client = new RestHighLevelClient(builder);
        return client;
    }

    // 异步httpclient的连接延时配置
    public void setConnectTimeOutConfig() {
        builder.setRequestConfigCallback(new RequestConfigCallback() {

            @Override
            public Builder customizeRequestConfig(Builder requestConfigBuilder) {
                requestConfigBuilder.setConnectTimeout(connectTimeOut);
                requestConfigBuilder.setSocketTimeout(socketTimeOut);
                requestConfigBuilder.setConnectionRequestTimeout(connectionRequestTimeOut);
                return requestConfigBuilder;
            }
        });
    }

    // 异步httpclient的连接数配置
    public void setMutiConnectConfig() {
        builder.setHttpClientConfigCallback(new HttpClientConfigCallback() {

            @Override
            public HttpAsyncClientBuilder customizeHttpClient(HttpAsyncClientBuilder httpClientBuilder) {
                httpClientBuilder.setMaxConnTotal(maxConnectNum);
                httpClientBuilder.setMaxConnPerRoute(maxConnectPerRoute);
                return httpClientBuilder;
            }
        });
    }
}

3：依赖注入使用

import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;

import java.io.IOException;

/**
 * @author wkl
 * @create 2022-06-28 18:48
 */
public class Test {

    @Autowired
    private RestHighLevelClient client;
    /**
     * 创建索引
     * @param
     * @throws IOException
     */
    @Test
    public void createIndex() throws IOException {
        CreateIndexRequest request = new CreateIndexRequest("六脉神剑");
        CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);
        System.out.println("createIndex: " + JSON.toJSONString(createIndexResponse));
    }
}