ES查询客户端初始化(RestHighLevelClient)

已于 2022-11-21 10:21:22 修改
阅读量2.6k 收藏 2
点赞数
分类专栏： java 文章标签： java 开发语言
于 2022-11-21 10:19:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40969452/article/details/127958893
版权 
ElasticSearchProperties  配置类，可以配置在中心中

public class ElasticSearchProperties {

    /**
     * 连接超时时间(毫秒)
     */
    private Integer connectTimeout = 3000;

    /**
     * socket 超时时间
     */
    private Integer socketTimeout = 30000;

    /**
     * 连接请求超时时间
     */
    private Integer connectionRequestTimeout = 500;

    /**
     * keepAlive策略时间
     */
    private Integer keepAliveStrategy = 60 * 1000;
}
EsClientFactory  es客户端工厂
/**
 * @author yangwenxin
 * @Date 2022/5/13
 * @Description
 */
@Slf4j
public class EsClientFactory {

    /**
     * 创建es客户端
     *
     * @param properties 配置信息
     * @param address    地址, 示例：127.0.0.1:9201,127.0.0.1:9202,127.0.0.1:9203
     * @param userName   用户名
     * @param password   密码
     * @return
     */
    public static RestHighLevelClient createRestHighLevelClient(ElasticSearchProperties properties, String address,
                                                                String userName, String password) {
        //ElasticSearch 连接地址地址
        HttpHost[] httpHosts = getElasticSearchHttpHosts(address);

        RestClientBuilder restClientBuilder = RestClient.builder(httpHosts).setRequestConfigCallback(requestConfigBuilder -> {
            //设置连接超时时间
            requestConfigBuilder.setConnectTimeout(properties.getConnectTimeout());
            requestConfigBuilder.setSocketTimeout(properties.getSocketTimeout());
            requestConfigBuilder.setConnectionRequestTimeout(properties.getConnectionRequestTimeout());
            return requestConfigBuilder;
        }).setHttpClientConfigCallback(httpClientBuilder -> {
            httpClientBuilder.disableAuthCaching();
            httpClientBuilder.setKeepAliveStrategy((response, context) -> properties.getKeepAliveStrategy());
            //设置账密
            return getHttpAsyncClientBuilder(httpClientBuilder, userName, password);
        });
        log.info("init esClient success, address : {}", address);
        return new RestHighLevelClient(restClientBuilder);
    }


    /**
     * ElasticSearch 连接地址
     * 多个逗号分隔
     * 示例：127.0.0.1:9201,127.0.0.1:9202,127.0.0.1:9203
     */
    private static HttpHost[] getElasticSearchHttpHosts(String address) {
        String[] hosts = address.split(",");
        HttpHost[] httpHosts = new HttpHost[hosts.length];
        for (int i = 0; i < httpHosts.length; i++) {
            String host = hosts[i];
            host = host.replaceAll("http://", "").replaceAll("https://", "");
            httpHosts[i] = new HttpHost(host.split(":")[0], Integer.parseInt(host.split(":")[1]), "http");
        }
        return httpHosts;
    }

    private static HttpAsyncClientBuilder getHttpAsyncClientBuilder(HttpAsyncClientBuilder httpClientBuilder, String username, String password) {
        if (StringUtils.isBlank(username) || StringUtils.isEmpty(password)) {
            return httpClientBuilder;
        }
        //账密设置
        CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        //es账号密码（一般使用,用户elastic）
        credentialsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(username, password));
        httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
        return httpClientBuilder;
    }
}
ElasticSearchClientService  es客户端初始化，从数据库中读取信息初始化客户端。其中DataSourceConfig就是配置了一些es链接的信息,账号密码地址等。
/**
 * @author yangwenxin
 * @Date 2022/5/13
 * @Description
 */
@Service
@Slf4j
public class ElasticSearchClientService {

    @Autowired
    private ElasticSearchProperties elasticSearchProperties;

    private Map<String, EsConfig> esClientMap = new HashMap<>();

    @PostConstruct
    public void init() {
        initEsClientMap();
    }

    /**
     * 初始化es数据源客户端到缓存
     */
    public void initEsClientMap() {
        // TODO 数据库查询数据源信息 自己项目中查询数据库方法，或者将ES信息配置在配置中心
        List<DataSourceConfig> dataSourceConfigs = Lists.newArrayList();
        if (CollectionUtils.isEmpty(dataSourceConfigs)) {
            return;
        }
        // address相同认为是一组  es数据源初始化address包含账号密码
        Map<String, List<DataSourceConfig>> dataSourceConfigMaps = dataSourceConfigs.stream().collect(
                Collectors.groupingBy(
                        DataSourceConfig::getAddress
                ));

        dataSourceConfigMaps.forEach((key, value) -> {
            DataSourceConfig dataSourceConfig = value.get(0);
            RestHighLevelClient restHighLevelClient = EsClientFactory.createRestHighLevelClient(
                    elasticSearchProperties,
                    dataSourceConfig.getAddress(),
                    dataSourceConfig.getUsername(),
                    dataSourceConfig.getPassword()
            );
            value.forEach(v -> {
                EsConfig esConfig = new EsConfig(restHighLevelClient, v.getInstance());
                esClientMap.put(v.getDataSourceNo(), esConfig);
            });
        });
    }

    @PreDestroy
    public void closeEsClient() {
        if (CollectionUtils.isEmpty(esClientMap)) {
            return;
        }
        esClientMap.forEach((key, value) -> {
            try {
                RestHighLevelClient client = value.getRestHighLevelClient();
                if (client != null) {
                    client.close();
                }
            } catch (Exception e) {
                log.error("close restHighLevelClient error! key: {},errMsg : {}", key, e.getMessage());
            }
        });
    }

    public EsConfig getEsConfigByNo(String dateSourceNo) {
        return esClientMap.get(dateSourceNo);
    }

    public synchronized void refreshEsDataSource(){
        initEsClientMap();
        log.info("refresh esDataSource success!");
    }


    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public static class EsConfig {
        /**
         * es客户端
         */
        private RestHighLevelClient restHighLevelClient;
        /**
         * 索引名称
         */
        private String dataSourceName;
    }
}

EsClientUtil 查询工具类
@Slf4j
public class EsClientUtil {

    private static final String DEFAULT_TYPE = "_doc";

    /**
     * query string 查询， queryString语法。语法自行百度
     * @param request
     * @return
     * @throws IOException
     */
    public static LogDataResp queryStringQuery(RestHighLevelClient client, QueryLogDataReq request) {
        String indexName = request.getQueryIndex();
        try {
            SearchRequest searchRequest = new SearchRequest(indexName);
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

            // 查询语句
            BoolQueryBuilder must =
                    QueryBuilders.boolQuery().must(
                            QueryBuilders.queryStringQuery(request.getQueryScript())
                    );

            // 时间范围  TODO 时区
            if(StringUtils.isNotBlank(request.getTimeFieldName()) && request.getTimeFrameMinutes() != null){
                RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery(request.getTimeFieldName())
                        .gte("now-" + request.getTimeFrameMinutes() + "m")
                        .lte("now")
                        // es时区默认是UTC
                        .timeZone("UTC");
                must.must(rangeQueryBuilder);
                // 根据时间降序排列
                searchSourceBuilder.sort(request.getTimeFieldName(), SortOrder.DESC);
            }
            searchSourceBuilder.query(must).from(0).size(request.getQuerySize());
            searchRequest.source(searchSourceBuilder);
            SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
            // 返回值解析
            return buildLogDataResponse(searchResponse,null);

        } catch (Exception e) {
            String errMsg = MessageFormat.format("EsClientUtil#queryStringQuery failed, params={0}", request);
            log.error(errMsg, e);
            return LogDataResp.buildFailed(e.getMessage());
        }
    }

    /**
     * 查询所有的索引
     * @param client
     * @return
     * @throws IOException
     */
    public static List<String> queryAllIndexAlias(RestHighLevelClient client) {
        try {
            GetAliasesRequest getAliasesRequest = new GetAliasesRequest();
            GetAliasesResponse getAliasesResponse = client.indices().getAlias(getAliasesRequest, RequestOptions.DEFAULT);
            Map<String, Set<AliasMetaData>> aliases = getAliasesResponse.getAliases();
            if(!aliases.isEmpty()){
                return new ArrayList<>(aliases.keySet());
            }
            return Arrays.asList();
        } catch (Exception e) {
            String errMsg = "EsClientUtil#queryAllIndexAlias error";
            log.error("errMsg" , e);
            throw new RuntimeException(errMsg, e);
        }
    }

    /**
     * 向索引插入单条记录
     * @param client
     * @param indexName    索引
     * @param docId        文档ID
     * @param docSource    文档 JSON格式
     * @return
     * @throws IOException
     */
    public static boolean insertDoc(RestHighLevelClient client, String indexName, String docId, Object docSource) {
        try {
            IndexRequest request = new IndexRequest(indexName,DEFAULT_TYPE);
            if (null != docId) {
                request.id(docId);
            }
            request.source(JSON.toJSONString(docSource), XContentType.JSON);
            IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);
            if ((indexResponse.status() == RestStatus.CREATED) || (indexResponse.status() == RestStatus.OK)) {
                return true;
            }
            log.error("insertDoc fail status:{} => {}", indexResponse.status(), indexResponse);
            return false;
        } catch (Exception e) {
            String errMsg =
                    MessageFormat.format("EsClientUtil#insertDoc failed, indexName={0},docId={1}, docSource={2}",
                            indexName,docId,docSource);
            log.error(errMsg, e);
            throw new RuntimeException(errMsg, e);
        }
    }

    /**
     * 向索引插入批量记录  不指定id
     * @param client
     * @param indexName   索引名称
     * @param docSources  数据 JSON格式
     * @return
     */
    public static boolean insertDocBulk(RestHighLevelClient client,String indexName, List<Object> docSources) {
        try {
            if (CollectionUtils.isEmpty(docSources)) {
                return false;
            }
            BulkRequest bulkRequest = new BulkRequest();
            docSources.forEach(docSource -> {
                IndexRequest request = new IndexRequest(indexName,DEFAULT_TYPE);
                request.source(JSON.toJSONString(docSource), XContentType.JSON);
                bulkRequest.add(request);
            });
            BulkResponse bulkResponse = client.bulk(bulkRequest, RequestOptions.DEFAULT);
            if (!bulkResponse.hasFailures()) {
                return true;
            }
            log.error("insertDocBulk fail status:{}, errorMsg:{}", bulkResponse.status(),
                    bulkResponse.buildFailureMessage());
            return false;
        } catch (Exception e) {
            String errMsg =
                    MessageFormat.format("EsClientUtil#insertDocBulk failed, indexName={0}",
                            indexName);
            log.error(errMsg, e);
            throw new RuntimeException(errMsg, e);
        }
    }

    /**
     * 向索引插入批量记录  指定id
     * @param client
     * @param indexName      索引名称
     * @param docSourceMap   key->Id value->docSource JSON格式
     * @return
     */
    public static boolean insertDocBulk(RestHighLevelClient client,String indexName, Map<String,Object> docSourceMap) {
        try{
            if (CollectionUtils.isEmpty(docSourceMap)) {
                return false;
            }
            BulkRequest bulkRequest = new BulkRequest();
            docSourceMap.forEach((key,value) -> {
                IndexRequest request = new IndexRequest(indexName,DEFAULT_TYPE);
                request.id(key);
                request.source(JSON.toJSONString(value), XContentType.JSON);
                bulkRequest.add(request);
            });
            BulkResponse bulkResponse = client.bulk(bulkRequest, RequestOptions.DEFAULT);
            if (!bulkResponse.hasFailures()) {
                return true;
            }
            log.error("insertDocBulk fail status:{}, errorMsg:{}", bulkResponse.status(),
                    bulkResponse.buildFailureMessage());
            return false;
        } catch (Exception e) {
            String errMsg =
                    MessageFormat.format("EsClientUtil#insertDocBulk failed, indexName={0}",
                            indexName);
            log.error(errMsg, e);
            throw new RuntimeException(errMsg, e);
        }
    }

    /**
     * 根据ID 删除文档
     * @param client
     * @param indexName  索引名称
     * @param docId
     * @return
     */
    public static boolean deleteDocById(RestHighLevelClient client, String indexName, String docId) {
        try{
            DeleteRequest deleteRequest = new DeleteRequest(indexName,DEFAULT_TYPE,docId);
            DeleteResponse delete = client.delete(deleteRequest, RequestOptions.DEFAULT);
            int total = delete.getShardInfo().getTotal();
            return total > 0;
        } catch (Exception e) {
            String errMsg =
                    MessageFormat.format("EsClientUtil#deleteDocById failed, indexName={0},docId={1} ",
                            indexName, docId);
            log.error(errMsg, e);
            throw new RuntimeException(errMsg, e);
        }
    }

    /**
     * 根据ID更新文档
     * @param client
     * @param indexName   索引名称
     * @param docId       文档ID
     * @param docSource   文档数据 JSON格式
     * @return
     */
    public static boolean updateDocById(RestHighLevelClient client, String indexName, String docId, Object docSource) {
        try{
            UpdateRequest updateRequest = new UpdateRequest(indexName,DEFAULT_TYPE,docId);
            updateRequest.doc(JSON.toJSONString(docSource),XContentType.JSON);
            // 执行更新
            UpdateResponse update = client.update(updateRequest, RequestOptions.DEFAULT);
            int total = update.getShardInfo().getTotal();
            return total > 0;
        } catch (Exception e) {
            String errMsg =
                    MessageFormat.format("EsClientUtil#updateDoc failed, indexName={0},docSource={1} ",
                            indexName, docSource);
            log.error(errMsg, e);
            throw new RuntimeException(errMsg, e);
        }
    }

    /**
     * 根据ID查询
     * @param client
     * @param indexName
     * @param docId
     * @return
     */
    public static <T> T queryDocById(RestHighLevelClient client, String indexName, String docId, Class<T> clazz) {
        try {
            GetRequest request = new GetRequest(indexName,DEFAULT_TYPE,docId);
            GetResponse response = client.get(request, RequestOptions.DEFAULT);
            if(response.isSourceEmpty()){
                return null;
            }
            return JSON.parseObject(response.getSourceAsString(), clazz);
        } catch (Exception e) {
            String errMsg =
                    MessageFormat.format("EsClientUtil#queryDocById failed, indexName={0},docId={1} ",
                            indexName, docId);
            log.error(errMsg, e);
            throw new RuntimeException(errMsg, e);
        }
    }

    /**
     * 根据条件查询分页
     * 注：from-size分页 可以随机跳转页面，在深度分页的情况下，效率是非常低的。深度分页参考search_after 不支持随机跳转，只支持
     * @param index    索引
     * @param pageNo   页码（第几页）
     * @param pageSize 页容量- Elasticsearch默认配置单次最大限制10000
     */
    public static <T> List<T> searchPageByIndex(RestHighLevelClient client, String index, SearchSourceBuilder searchSourceBuilder, Integer pageNo, Integer pageSize, Class<T> clazz) {
        if(searchSourceBuilder == null){
            searchSourceBuilder = new SearchSourceBuilder();
        }
        searchSourceBuilder.from((pageNo-1)*pageSize);
        searchSourceBuilder.size(pageSize);
        return searchByQuery(client, index, searchSourceBuilder, clazz);
    }

    /**
     * 条件查询
     *
     * @param indexName         索引
     * @param sourceBuilder 条件查询构建起
     * @param <T>           数据类型
     * @return T 类型的集合
     */
    public static <T> List<T> searchByQuery(RestHighLevelClient client, String indexName, SearchSourceBuilder sourceBuilder, Class<T> clazz) {
        try {
            // 构建查询请求
            SearchRequest searchRequest = new SearchRequest(indexName).source(sourceBuilder);
            // 获取返回值
            SearchResponse response = client.search(searchRequest, RequestOptions.DEFAULT);
            SearchHit[] hits = response.getHits().getHits();
            if (null == hits || hits.length == 0) {
                return new ArrayList<>(0);
            }
            List<T> resultList = new ArrayList<>(hits.length);
            for (SearchHit hit : hits) {
                resultList.add(JSON.parseObject(hit.getSourceAsString(), clazz));
            }
            return resultList;
        } catch (Exception e) {
            String errMsg =
                    MessageFormat.format("EsClientUtil#searchByQuery failed, indexName={0}, sourceBuilder={1} ",
                            sourceBuilder);
            log.error(errMsg, e);
            throw new RuntimeException(errMsg, e);
        }
    }


    /**
     * 结果解析构建返回结果
     * @param searchResponse
     * @param aggName
     * @return
     */
    private static LogDataResp buildLogDataResponse(SearchResponse searchResponse, String aggName){
        LogDataResp logDataResponse = new LogDataResp();
        if(searchResponse.status().getStatus() != RestStatus.OK.getStatus()){
            logDataResponse.setSucceeded(Boolean.FALSE);
            return logDataResponse;
        }

        long totalHits = searchResponse.getHits().getTotalHits();
        logDataResponse.setTotalHit(totalHits);
        SearchHit[] hits = searchResponse.getHits().getHits();
        if(hits.length > 0){
            List<Map> hitSourceList = new ArrayList<>();
            for(SearchHit hit : hits){
                hitSourceList.add(hit.getSourceAsMap());
            }
            logDataResponse.setHitSourceList(hitSourceList);
        }

        if(aggName != null){
            Aggregations aggregations = searchResponse.getAggregations();
            Terms aggregation = (Terms)aggregations.get(aggName);
            List<? extends Terms.Bucket> buckets = aggregation.getBuckets();
            Map map = Maps.newHashMap();
            List<Map> aggregationBucketList = new ArrayList<>();
            for (Terms.Bucket bucket : buckets) {
                map.put(bucket.getKeyAsString(),bucket.getDocCount());
            }
            aggregationBucketList.add(map);
            logDataResponse.setAggregationBucketList(aggregationBucketList);
        }
        return logDataResponse;
    }


}

另外，如果说把es当成一个数据库使用，可以看下开源项目easy-es，操作更方便。文档地址:快速开始 | Easy-Es

慌乱的小绵羊
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Elasticsearch数据库的连接客户端
03-24
图形化界面连接Elasticsearch,方便开发人员操作,elasticsearch的客户端比较出名的就是elasticsearch head 和Kibana了， 但是elasticsearch head已经停止更新，且样式老旧，功能不全； 而Kibana虽功能全面，但是启动...
ElasticSearch客户端工具
09-11
比较好用的ElasticSearch客户端工具，可以监控ES集群信息。
elasticsearch学习（七）：es客户端RestHighLevelClient
热门推荐
weixin_40482816的博客
09-24 3万+
Java Low Level REST Client：ES官方的低级客户端。低级别的客户端通过http与Elasticearch集群通信。Java High Level REST Client：ES官方的高级客户端。基于上面的低级客户端，也是通过HTTP与ES集群进行通信。它提供了更多的接口。客户端(Client) Jar包的版本尽量不要大于Elasticsearch本体的版本，否则可能出现客户端中使用的某些API在Elasticsearch中不支持。
es的rest-high-level-client使用
长河的博客
10-02 1万+
elasticsearch的官方文档的链接在此 https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/index.html 如果不想看这文章, 请出门左转直接去看官方的api, 写的非常详细, 也写的很多 简单介绍下两种api Java REST Client 有两种风格： Java Low L...
连接elasticsearch，并设置超时时间
qq_50761817的博客
04-30 273
【代码】连接elasticsearch，并设置超时时间。
Elasticsearch rest-high-level-client 基本操作
qq_34285557的博客
10-25 4378
Elasticsearch rest-high-level-client 基本操作 本篇主要讲解一下 rest-high-level-client 去操作 Elasticsearch , 虽然这个客户端在后续版本中会慢慢淘汰,但是目前大部分公司中使用Elasticsearch 版本都是6.x 所以这个客户端还是有一定的了解 前置准备 准备一个SpringBoot环境 2.2.11 版本 准备一个Elasticsearch 环境 我这里是8.x版本 引入依赖 elasticsearch-rest
ElasticSearch7.3学习(十六)----RestHighLevelClient Java api实现索引的创建、删除、是否存在、关闭、开启
09-08 2658
注意：导入的包区别，不同的包创建索引的方式不同。博主亲身实践，具体体现在createIndexRequest.mapping()里面。读者可自行试验。可以看到上述两种方式导入的包的子类名是相同的，但是具体对索引的操作方式可能是不同的。具体的区别博主暂时还不清楚，后续若有进展再在此处更新。
ElasticSearch篇——测试类测试restHighLevelClient常见API，一篇文章带你彻底吃透ES集成到Spring中如何使用，史上最全面、最详细使用方法分享！！！！！！
我热爱学习，也乐于分享。无论是科技前沿的洞见，还是生活中的小技巧，我都会在这里与你分享。我相信，知识就是力量，而分享则能让这份力量得到更好的传递。
12-10 670
话不多说，直接开冲，大家准备好~创建索引测试用例控制台：查看ES的head可视化工具刚刚创建的索引，创建成功！
ES查询客户端，elasticsearch可视化工具 elasticsearch查询客户端
最新发布
06-20
ES查询客户端，elasticsearch可视化工具。elasticsearch查询客户端
elasticsearch-demo：es的三种客户端查询
02-21
弹性搜索演示es的三种客户端查询
基于SpringBoot的Elasticsearch客户端调用封装工具设计源码
03-29
EsClientRHL是一个可基于springboot的elasticsearch客户端调用封装工具，通过elasticsearch官网推荐的RestHighLevelClient实现，内置了es索引结构工具、es索引数据增删改工具、es查询工具、es数据分析工具或者es。...
Es7.x使用RestHighLevelClient进行增删改和批量操作
杜海的博客
01-27 1万+
引入依赖 初始化RestHighLevelClient和BulkProcessor对象 增删改操作 3.1 数据准备 3.2 单条数据异步插入 3.3 单条数据同步插入 3.4 批量插入 3.5 更新操作 3.6 带条件的更新语句 3.7 批量更新 3.8 删除操作 3.9 条件删除 Java层面操作elasticSearch7.x，为了便于操作，不集成Spring，使用main方法进行调用。 1. 引入依赖 <!--解决：java.lang.NoCla
RestHighLevelClient操作7.10.0（一）ElasticSearch 连接配置
xuzai
12-22 6486
ES 的更新速度非常快，官方推出的 Java 客户端 elasticsearch-rest-high-level-client，它的代码写法跟 DSL 语句很相似，这里我们就采用这种方式进行演练。 RestHighLevelClient操作7.10.0（一）ElasticSearch 连接配置一、查询官方文档二、Maven 引入相关依赖三、ElasticSearch 连接配置1、application.yml 配置文件2、ES 连接参数类3、初始化RestHighLevelClient对象四、swagge.
SpringBoot整合Elasticsearch7基于RestHighLevelClient工具类(分页，高亮)
单筱风的博客
08-24 8983
1.主要依赖 <!-- https://mvnrepository.com/artifact/cn.hutool/hutool-all --> <dependency> <groupId>cn.hutool</groupId> <artifactId>hutool-all</artifactId> <version>5.3.10&lt
ES的transportClient初始化过程解析
qqqq0199181的博客
03-12 3649
TransportClient的初始化流程 创建client的代码 在初始化TransportClient的时候，我们将嗅探模式开启，即client.transport.sniff设置为true. Settings settings = Settings.settingsBuilder() .put("client.transport.sniff", true).p...
ES BulkRequest 写入索引数据失败排查和解决
小杨互联网
08-18 5563
1，查看我们的索引mapping有没有问题，是不是索引的数据格式导致我们数据写入不进去，基本上百分之九十就是这个问题，但是我们的并不是。我们的日期格式在es是yyyymmdd hhmmss格式但是这里是个时间蹉格式，肯定就不对了，但是你会说我jsonfamart也不行吗？这样也不行，我序列化的时候tostring不行吗，答案是不行的，只有在序列化的时候转换一下。问题场景：1，使用BulkRequest写入索引数据不生效，接口正常返回，索引没有数据。这个错就很明显了我们的时间格式不对对不对，咋解决呢？...
Elasticsearch_初始化配置
AngusDavis的博客
09-12 3095
Java代码   构建ES集群环境经常用到的配置：   1.action.auto_create_index --配置是否自动创建索引（true OR false);   2.gateway.type -- (fs, none, local);   3.cluster.routing.schedule 如（50ms)， 发现新节点时间            Settin
elasticsearch系列-Java客户端的查询操作
在途中
02-02 1220
在上一篇中，我们介绍了如何使用Java客户端对elasticsearch进行索引的创建、mapping信息的设置和文档的添加，在本篇中我们将主要介绍通过Java客户端查询文档的操作。 使用Java客户端查询操作步骤 创建一个client对象 创建一个查询对象，通过QueryBuilders进行创建，其由很多实现的子类。 使用client执行查询操作，需提前设置查询参数 得到查询返回的结果，默认返...
RestHighLevelClient初始化
05-17
RestHighLevelClient是Elasticsearch官方提供的Java客户端，用于与Elasticsearch进行交互。下面是RestHighLevelClient初始化的示例代码： ```java RestHighLevelClient client = new RestHighLevelClient( RestClient.builder( new HttpHost("localhost", 9200, "http"), new HttpHost("localhost", 9201, "http"))); ``` 这里创建了一个RestHighLevelClient对象，并指定了Elasticsearch集群中的两个节点（localhost:9200和localhost:9201）。这样，客户端就可以与这两个节点进行通信了。注意，需要确保节点的地址和端口号与实际情况相符。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值