程序员经验分享-hwhale

Elasticsearch RestHighLevelClient API 使用总结

2023-10-26

Elasticsearch RestHighLevelClient API 使用总结

题记

深秋初冬的一个晚上，突然间收到业务一个需求，要在老系统上使用新系统Elasticsearch库的数据。

目前项目情况，新、老系统并行运行，根据产品、渠道路由，但是老系统未使用Elasticsearch 新系统基础框架Spring Cloud Alibaba version -> 2.2.1RELEASE，老系统基础框架 Spring Framework version -> 4.3.24RELEASE。

技术响应

为了满足业务需求，经过技术分析讨论有两种实现方案：

方案一：

在新系统中暴露 HTTP 服务接口，让老系统直接调用新系统，完成数据获取；

方案二：

在老系统以最小侵入单元的形式集成 Elasticsearch，完成数据获取；

经过系统交互分析，从系统架构设计角度考虑，为减少系统耦合，采用方案二完成数据接入。

Elasticsearch 接入

maven 依赖
		<dependency>
			<groupId>org.elasticsearch</groupId>
			<artifactId>elasticsearch</artifactId>
			<version>6.8.6</version>
		</dependency>
		<dependency>
			<groupId>org.elasticsearch.client</groupId>
			<artifactId>elasticsearch-rest-client</artifactId>
			<version>6.8.6</version>
		</dependency>
		<dependency>
			<groupId>org.elasticsearch.client</groupId>
			<artifactId>elasticsearch-rest-high-level-client</artifactId>
			<version>6.8.6</version>
		</dependency>

注释：本文采用version -> 6.8.6 客户端完成接入，原因：与生产Elasticsearch版本保持一致。

实现自动装配

import lombok.extern.slf4j.Slf4j;
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.impl.client.BasicCredentialsProvider;
import org.apache.http.message.BasicHeader;
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;

/**
 * elasticsearch 配置类
 */
@Slf4j
@Configuration
public class ElasticsearchConfig {

    @Value("${elasticsearch.cluster.address}")
    private String clusterAddress;

    @Value("${elasticsearch.username}")
    private String username;

    @Value("${elasticsearch.password}")
    private String password;

    @Value("${elasticsearch.shards}")
    private Integer numberOfShards;

    @Value("${elasticsearch.replicas}")
    private Integer numberOfReplicas;

    @Value("${elasticsearch.connect_timeout}")
    private Long connectTimeout;

    @Value("${elasticsearch.socket_timeout}")
    private Long socketTimeout;

    public static RestHighLevelClient client = null;

    public Integer getNumberOfShards() {
        return numberOfShards;
    }

    public Integer getNumberOfReplicas() {
        return numberOfReplicas;
    }

    /**
     * RestHighLevelClient bean创建
     */
    @Bean
    public RestHighLevelClient restClient() {
        final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
        credentialsProvider.setCredentials(AuthScope.ANY,
                new UsernamePasswordCredentials(username, password));
        Header[] defaultHeaders = {new BasicHeader("content-type", "application/json")};
        RestClientBuilder restClientBuilder = RestClient.builder(HttpHost.create(clusterAddress));
        restClientBuilder
                .setHttpClientConfigCallback(httpAsyncClientBuilder -> httpAsyncClientBuilder.setDefaultCredentialsProvider(credentialsProvider))
                .setDefaultHeaders(defaultHeaders)
                .setRequestConfigCallback(requestConfigBuilder -> {
                    // 连接5秒超时，套接字连接60s超时
                    return requestConfigBuilder.setConnectTimeout(connectTimeout.intValue()).setSocketTimeout(socketTimeout.intValue());
                })
                .setHttpClientConfigCallback(httpClientBuilder -> {
                    httpClientBuilder.disableAuthCaching();
                    return httpClientBuilder.setDefaultCredentialsProvider(credentialsProvider);
                });

        client = new RestHighLevelClient(restClientBuilder);
        return client;
    }


}
Elasticsearch 持久层接入

import cn.hutool.core.map.MapUtil;
import lombok.extern.slf4j.Slf4j;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.support.WriteRequest;
import org.elasticsearch.action.support.master.AcknowledgedResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.core.CountRequest;
import org.elasticsearch.client.core.CountResponse;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.RangeQueryBuilder;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.elasticsearch.xcontent.XContentType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.util.*;

/**
 * elasticsearch 持久层
 */
@Slf4j
@Service
public class ElasticsearchRepository {

    @Autowired
    private RestHighLevelClient client ;

    private final RequestOptions options = RequestOptions.DEFAULT;


    /**
     * 写入数据
     * @param indexName
     * @param dataMap 数据实体
     * @return
     */
    public boolean insert (String indexName, Map<String,Object> dataMap){

        try {
            BulkRequest request = new BulkRequest();
            request.add(new IndexRequest(indexName,"record").id(dataMap.remove("id").toString())
                    .opType("create").source(dataMap, XContentType.JSON));
            client.bulk(request, options);
            return Boolean.TRUE ;
        } catch (Exception e){
            log.error("ElasticsearchRepository#insert, 索引名称:{}, 执行异常:{}", indexName, e);
        }
        return Boolean.FALSE;
    }

    /**
     * 批量写入数据
     * @param indexName
     * @param userIndexList
     * @return
     */
    public boolean batchInsert (String indexName, List<Map<String,Object>> userIndexList){

        try {
            BulkRequest request = new BulkRequest();
            for (Map<String,Object> dataMap:userIndexList){
                request.add(new IndexRequest(indexName,"record").id(dataMap.remove("id").toString())
                        .opType("create").source(dataMap,XContentType.JSON));
            }
            client.bulk(request, options);
            return Boolean.TRUE ;
        } catch (Exception e){
            log.error("ElasticsearchRepository#batchInsert, 索引名称:{}, 执行异常:{}", indexName, e);
        }
        return Boolean.FALSE;
    }


    /**
     * 更新数据
     * 可以直接修改索引结构
     * @param indexName
     * @param dataMap
     * @return
     */
    public boolean update (String indexName, Map<String,Object> dataMap){

        try {
            UpdateRequest updateRequest = new UpdateRequest(indexName,"record", dataMap.remove("id").toString());
            updateRequest.setRefreshPolicy(WriteRequest.RefreshPolicy.IMMEDIATE);
            updateRequest.doc(dataMap) ;
            client.update(updateRequest, options);
            return Boolean.TRUE ;
        } catch (Exception e){
            log.error("ElasticsearchRepository#update, 索引名称:{}, 执行异常:{}", indexName, e);
        }
        return Boolean.FALSE;
    }


    /**
     * 根据 id 及索引删除数据
     * @param indexName
     * @param id
     * @return
     */
    public boolean delete (String indexName, String id){

        try {
            DeleteRequest deleteRequest = new DeleteRequest(indexName,"record", id);
            client.delete(deleteRequest, options);
            return Boolean.TRUE ;
        } catch (Exception e){
            log.error("ElasticsearchRepository#delete, 索引名称:{}, 执行异常:{}", indexName, e);
        }
        return Boolean.FALSE;
    }


    /**
     * 判断索引是否存在
     * @param indexName
     * @return
     */
    public boolean checkIndex (String indexName) {

        try {
            return client.indices().exists(new GetIndexRequest(indexName), options);
        } catch (IOException e) {
            log.error("ElasticsearchRepository#checkIndex, 索引名称:{}, 执行异常:{}", indexName, e);
        }
        return Boolean.FALSE ;
    }


    /**
     * 创建索引
     * @param indexName
     * @param columnMap
     * @return
     */
    public boolean createIndex (String indexName ,Map<String, Object> columnMap){

        try {
            if(!checkIndex(indexName)){
                CreateIndexRequest request = new CreateIndexRequest(indexName);
                if (columnMap != null && columnMap.size()>0) {
                    Map<String, Object> source = new HashMap<>();
                    source.put("properties", columnMap);
                    request.mapping(source);
                }
                client.indices().create(request, options);
                return Boolean.TRUE ;
            }
        } catch (IOException e) {
            log.error("ElasticsearchRepository#createIndex, 索引名称:{}, 执行异常:{}", indexName, e);
        }
        return Boolean.FALSE;
    }


    /**
     * 删除索引
     * @param indexName
     * @return
     */
    public boolean deleteIndex(String indexName) {

        try {
            if(checkIndex(indexName)){
                DeleteIndexRequest request = new DeleteIndexRequest(indexName);
                AcknowledgedResponse response = client.indices().delete(request, options);
                return response.isAcknowledged();
            }
        } catch (Exception e) {
            log.error("ElasticsearchRepository#deleteIndex, 索引名称:{}, 执行异常:{}", indexName, e);
        }
        return Boolean.FALSE;
    }


    /**
     * 查询满足条件的数据条数
     * @param indexName
     * @param matchMap
     * @return
     */
    public Long count (String indexName, LinkedHashMap<String, Object> matchMap){

        // 查询器构造
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();

        // 查询时间范围内的数据
        if (MapUtil.isNotEmpty(matchMap)){
            if (matchMap.containsKey("startTime") && matchMap.containsKey("endTime")){
                RangeQueryBuilder rangequerybuilder = QueryBuilders
                        .rangeQuery("createTime")
                        .from(Long.parseLong(String.valueOf(matchMap.get("startTime"))))
                        .to(Long.parseLong(String.valueOf(matchMap.get("endTime"))));
                queryBuilder.must(rangequerybuilder);
            }

            // 移除时间查询条件
            matchMap.remove("startTime");
            matchMap.remove("endTime");

            // 时间查询条件外的参数拼接
            if (MapUtil.isNotEmpty(matchMap)){
                matchMap.forEach((k, v) -> {queryBuilder.must(QueryBuilders.termQuery(k, v));});
                sourceBuilder.query(queryBuilder);
            }
        }

        CountRequest countRequest = new CountRequest(indexName);
        countRequest.source(sourceBuilder);
        try {
            CountResponse countResponse = client.count(countRequest, options);
            return countResponse.getCount();
        } catch (Exception e) {
            log.error("ElasticsearchRepository#count, 索引名称:{}, 执行异常:{}", indexName, e);
        }
        return 0L;
    }


    /**
     * 查询满足条件的数据集合
     * 适用于满足条件的数据条数可控的全量查询 PS：单次查询条数不超过 10000条
     * @param indexName
     * @param matchMap
     * @return
     */
    public List<Map<String,Object>> list (String indexName, LinkedHashMap<String, Object> matchMap) {

        // 查询条件,指定时间并过滤指定字段值
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();

        // 查询参数拼接
        if (MapUtil.isNotEmpty(matchMap)){
            matchMap.forEach((k, v) -> {queryBuilder.must(QueryBuilders.termQuery(k, v));});
        }
        sourceBuilder.query(queryBuilder);
        SearchRequest searchRequest = new SearchRequest(indexName);
        searchRequest.source(sourceBuilder);
        try {
            SearchResponse searchResp = client.search(searchRequest, options);
            List<Map<String,Object>> data = new ArrayList<>() ;
            SearchHit[] searchHitArr = searchResp.getHits().getHits();
            for (SearchHit searchHit:searchHitArr){
                Map<String,Object> temp = searchHit.getSourceAsMap();
                temp.put("id",searchHit.getId()) ;
                data.add(temp);
            }
            return data;
        } catch (Exception e) {
            log.error("ElasticsearchRepository#list, 索引名称:{}, 执行异常:{}", indexName, e);
        }
        return null ;
    }


    /**
     * 根据查询条件，分页查询
     * 适用于满足条件的数据总量较大的循环查询场景
     * @param indexName
     * @param offset 偏移量
     * @param size 条数
     * @param matchMap
     * @return
     */
    public List<Map<String,Object>> page (String indexName, Integer offset, Integer size, LinkedHashMap<String, Object> matchMap) {

        // 添加分页参数
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.from(offset);
        sourceBuilder.size(size);
        sourceBuilder.sort("createTime", SortOrder.DESC);
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();

        // 查询时间范围内的数据
        if (MapUtil.isNotEmpty(matchMap)){
            if (matchMap.containsKey("startTime") && matchMap.containsKey("endTime")){
                RangeQueryBuilder rangequerybuilder = QueryBuilders
                        .rangeQuery("createTime")
                        .from(Long.parseLong(String.valueOf(matchMap.get("startTime"))))
                        .to(Long.parseLong(String.valueOf(matchMap.get("endTime"))));
                queryBuilder.must(rangequerybuilder);
            }

            // 移除时间查询条件
            matchMap.remove("startTime");
            matchMap.remove("endTime");

            // 时间查询条件外的参数拼接
            if (MapUtil.isNotEmpty(matchMap)){
                matchMap.forEach((k, v) -> {queryBuilder.must(QueryBuilders.termQuery(k, v));});
                sourceBuilder.query(queryBuilder);
            }
        }

        // 查询请求
        SearchRequest searchRequest = new SearchRequest(indexName);
        searchRequest.source(sourceBuilder);

        try {
            SearchResponse searchResp = client.search(searchRequest, options);
            List<Map<String,Object>> data = new ArrayList<>() ;
            SearchHit[] searchHitArr = searchResp.getHits().getHits();
            for (SearchHit searchHit:searchHitArr){
                Map<String,Object> temp = searchHit.getSourceAsMap();
                temp.put("id",searchHit.getId()) ;
                data.add(temp);
            }
            return data;
        } catch (Exception e) {
            log.error("ElasticsearchRepository#page, 索引名称:{}, 执行异常:{}", indexName, e);
        }
        return null ;
    }


    /**
     * 根据条件查询，按照创建时间进行降序排列
     * 可扩展，根据更新时间、 id、证件号等
     * @param indexName
     * @param matchMap
     * @return
     */
    public List<Map<String,Object>> sort (String indexName, LinkedHashMap<String, Object> matchMap) {

        // 先升序时间，在倒序年龄
        SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
        sourceBuilder.sort("createTime", SortOrder.ASC);

        // 查询器构造
        BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();

        // 查询时间范围内的数据
        if (MapUtil.isNotEmpty(matchMap)){
            if (matchMap.containsKey("startTime") && matchMap.containsKey("endTime")){
                RangeQueryBuilder rangequerybuilder = QueryBuilders
                        .rangeQuery("createTime")
                        .from(Long.parseLong(String.valueOf(matchMap.get("startTime"))))
                        .to(Long.parseLong(String.valueOf(matchMap.get("endTime"))));
                queryBuilder.must(rangequerybuilder);
            }

            // 移除时间查询条件
            matchMap.remove("startTime");
            matchMap.remove("endTime");

            // 时间查询条件外的参数拼接
            if (MapUtil.isNotEmpty(matchMap)){
                matchMap.forEach((k, v) -> {queryBuilder.must(QueryBuilders.termQuery(k, v));});
                sourceBuilder.query(queryBuilder);
            }
        }

        SearchRequest searchRequest = new SearchRequest(indexName);
        searchRequest.source(sourceBuilder);
        try {
            SearchResponse searchResp = client.search(searchRequest, options);
            List<Map<String,Object>> data = new ArrayList<>() ;
            SearchHit[] searchHitArr = searchResp.getHits().getHits();
            for (SearchHit searchHit:searchHitArr){
                Map<String,Object> temp = searchHit.getSourceAsMap();
                temp.put("id",searchHit.getId()) ;
                data.add(temp);
            }
            return data;
        } catch (Exception e) {
            log.error("ElasticsearchRepository#sort, 索引名称:{}, 执行异常:{}", indexName, e);
        }
        return null ;
    }


}
单元测试

采用 Junit实现

总结

1.在承接业务需求时，首先要结合功能实现的复杂度，考虑架构的合理性，在相对更合理的系统设计背景下进行功能设计、开发；
2.进行技术开发时，首先要考虑功能对模块的侵入性，在最小侵入性的前提下，采用与基础框架融合的方式，完成开发任务。

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

tools

软件设计

elasticsearch

大数据

搜索引擎

Elasticsearch RestHighLevelClient API 使用总结 的相关文章

随机推荐

  • 单片机程序跑飞原因

    参考 单片机程序又跑飞 作者 嵌入式ARM 网址 https mp weixin qq com s a22zVdSfCqWjSmlBxK2R1Q 目录 数组越界 溢出 中断服务程序缺失 看门狗复位 单片机中有看门狗 长时间不喂狗 程序就会复

  • 从零开始使用docker部署Go Web App

    docker的基本使用 如何在ubuntu 16 04上安装docker 以及docker的基本使用可以参考我的上一篇博客 服务计算之玩转 Docker dockerfile的编写 要在docker上部署应用一定绕不开编写dockerfil

  • 三种循环详解和练习

    循环讲解和练习 1 1 for循环语句基本格式 for 语句1 表达式 语句2 语句块 大多数问题我们都可以通过for的嵌套进行了解 for 语句1 表达式 语句2 for 语句1 表达式 语句2 语句块 for int i 0 i lt

  • Android常见的adb命令

    查看当前的device adb devices 如果有多个devices adb s 设备号 其他指令 查看顶部Activity windows环境下 adb shell dumpsys activity findstr mFocusedA

  • linux安装docker 教程

    1 卸载之前安装的docker sudo 以管理员身份运行 sudo yum remove docker docker client docker client latest docker common docker latest dock

  • 学习机器学习选择python，还是spark，Scala？

    这种问法是初接触者的困惑 尤其是现在铺天盖地的python机器学习课程 会让人以为python就是工作中主流了 那spark是干什么呢 Scala这个名字好像也听过 以下摘自一段相对好理解的回答 spark是用在大数据场景中的 python

  • Premiere Pro CC2018安装资料及安装教程

    简介 Adobe Premiere是一款常用的视频编辑软件 由Adobe公司推出 现在常用的版本有CS4 CS5 CS6 CC 2014 CC 2015 CC 2017 CC 2018以及CC 2019版本 Adobe Premiere是一

  • 论文写作 12: 算法伪代码 (含实例)

    算法伪代码是论文的核心之一 需要说明输入 输出 方法 函数 名可写可不写 如果被别的方法调用就必须写 需要写出主要步骤的注释 长度控制在 15 30 行 可使用数学式子或对已有数学式子的引用 不重要的步骤可以省略 一般需要进行时间 空间复杂

  • 详解Nginx proxy_pass 使用

    前言 日常不管是研发还是运维 都多少会使用Nginx服务 很多情况Nginx用于反向代理 那就离不开使用proxy pass 有些同学会对 proxy pass 转发代理时 后面url加 后面url没有 后面url添加其它路由等场景 不能很

  • en结尾的单词_知识丨英语单词中最常见的328个前缀后缀，高效背单词必备！

    北京高考资讯 争取给你更好的 更新鲜的高考资讯 记忆单词最好的两个办法就是 结合语境和运用构词法 构词法包括派生 即我们平时说的前后缀 合成和转化 而派生在构词法中是最重要的 今天老师带大家来看一下高中阶段涉及到的328个前后缀都有哪些 记

  • 这19款最好用的免费安全工具，使用不当或许面临牢狱之灾。

    前言 大家好 我是周杰伦 工具本身没有好坏 但如果能充分利用好的工具 往往能达到意想不到的效果 安全行业尤其如此 这期推荐的是一些免费而且很优秀的安全软件工具 无论是渗透测试 开源情报 还是漏洞评估 都能让安全人的日常工作更轻松 将近 20

  • 软件测试面试题—选择题2

    选择题 1 验收测试的测试用例主要根据 的结果来设计 A 需求分析 B 源程序 C 概要设计 D 详细设计 答案 A 2 以下不属于应用系统中的缺陷类型的是 A 不恰当的需求解释 B 用户指定的错误需求 C 设计人员的习惯不好 D 不正确的

  • 最简单的分类算法之一：KNN（原理解析+代码实现）

    KNN K Nearest Neighbor 即K最邻近算法 是数据挖掘分类技术中最简单的方法之一 简单来说 它是根据 最邻近 这一特征来对样本进行分类 目录 1 大致了解KNN 2 原理分析 2 1一些数学知识 2 2算法思想 3 代码实

  • linux 在服务器上挂硬盘,linux如何挂载硬盘linux服务器上挂载磁盘（图文详解）...

    博主最近在研究服务器运维 由于Linux服务器相对比较困难 所以博主对她情有独钟 而window服务器几乎跟我们平常使用的电脑一样 相对简单感觉索然无味 下面正式进入主题教大家linux如何挂载硬盘 首先解答一个新手朋友都会问的问题 而且这

  • Inno setup Run Win7管理员运行属性

    runascurrentuser If this flag is specified the spawned process will inherit Setup Uninstall s user credentials typically

  • 《Angular2入门系列实践》——实现页面动画效果

    前言 在前端的路上越走越远 也希望利用angular2使自己的页面效果更加美观 所以从官网上学习了一下 内容 1 写animation ts import animate AnimationEntryMetadata state style

  • leetcode暴力屎山代码（一）——leetcode4

    题目 给定两个大小分别为 m 和 n 的正序 从小到大 数组 nums1 和 nums2 请你找出并返回这两个正序数组的 中位数 思路 由于两数组是有序排列的 所以可以通过计算两个数组中位数的索引 mid 并通过双指针从左到右遍历找到第mi

  • 重学webpack5——生产环境配置

    目录 前言 一 CSS文件 1 提取css 成单独文件 2 CSS兼容性处理 3 压缩CSS 二 Js文件 1 JS语法检查eslint 2 JS兼容性处理 3 JS压缩 三 HTML文件 四 生产环境总结 前言 生产环境是能让代码优化上线

  • selenium应用

    Selenium 学习参考 http selenium python readthedocs io 自动化测试工具 它支持各种浏览器 包括 Chrome Safari Firefox 等主流界面式浏览器 如果在这些浏览器里面安装一个 Sel

  • Elasticsearch RestHighLevelClient API 使用总结

    Elasticsearch RestHighLevelClient API 使用总结 题记 深秋初冬的一个晚上 突然间收到业务一个需求 要在老系统上使用新系统Elasticsearch库的数据 目前项目情况 新 老系统并行运行 根据产品 渠

热门标签