devbox
Cpp五条
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java与Elasticsearch的API实现工具类（一）——条件查询_java 查询接口通用条件对象

作者：Cpp五条 | 2024-02-08 09:52:24

赞

踩

java 查询接口通用条件对象

相关代码已上传gitee

https://gitee.com/gangye/elasticsearch_demo

首先搭建一个项目，引入pom依赖，引入es的相关jar包

  1. <!--引入elasticsearch相关jar包-->
  2. <dependency>
  3.     <groupId>org.elasticsearch.client</groupId>
  4.     <artifactId>elasticsearch-rest-high-level-client</artifactId>
  5.     <version>6.8.8</version>
  6.     <exclusions>
  7. 	<exclusion>
  8. 	    <groupId>org.elasticsearch</groupId>
  9. 	    <artifactId>elasticsearch</artifactId>
  10. 	</exclusion>
  11.     </exclusions>
  12. </dependency>
  13.  
  14. <dependency>
  15.     <groupId>org.elasticsearch.client</groupId>
  16.     <artifactId>elasticsearch-rest-client</artifactId>
  17.     <version>6.8.8</version>
  18. </dependency>
  19.  
  20. <dependency>
  21.     <groupId>org.elasticsearch</groupId>
  22.     <artifactId>elasticsearch</artifactId>
  23.     <version>6.8.8</version>
  24. </dependency>

在application.yml中配置相关属性值，此处使用的es的集群地址是本地多个虚拟机启动的集群模式

  1. elasticsearch:
  2.   config:
  3.     host: 192.168.236.131:9200,192.168.236.130:9200,192.168.236.129:9200
  4.     requestType: csrcb
  5.     connectTimeout: 1000
  6.     socketTimeout: 5000
  7.     maxRetryTimeout: 5000
  8.     connRequestTimeOut: 1000

定义配置类获取配置文件的属性值

  1. package com.csrcb.config;
  2.  
  3. import lombok.Data;
  4. import org.springframework.beans.factory.annotation.Value;
  5. import org.springframework.context.annotation.Configuration;
  6.  
  7. /**
  8.  * @Classname EsClientConfig
  9.  * @Description 获取es的相关配置属性，以及属性值
  10.  * @Date 2021/6/2 17:30
  11.  * @Created by gangye
  12.  */
  13. @Configuration
  14. @Data
  15. public class EsClientConfig {
  16.     @Value("${elasticsearch.config.host}")
  17.     private String hosts;
  18.  
  19.     @Value("${elasticsearch.config.connectTimeout}")
  20.     private int connectTimeout;
  21.  
  22.     @Value("${elasticsearch.config.socketTimeout}")
  23.     private int socketTimeout;
  24.  
  25.     @Value("${elasticsearch.config.maxRetryTimeout}")
  26.     private int maxRetryTimeout;
  27.  
  28.     @Value("${elasticsearch.config.connRequestTimeOut}")
  29.     private int connRequestTimeOut;
  30.  
  31. }

 定义es的客户端连接

  1. package com.csrcb.config;
  2.  
  3. import com.csrcb.common.DefineConstant;
  4. import org.apache.http.HttpHost;
  5. import org.apache.http.client.config.RequestConfig;
  6. import org.elasticsearch.client.RestClient;
  7. import org.elasticsearch.client.RestClientBuilder;
  8. import org.elasticsearch.client.RestHighLevelClient;
  9.  
  10. import java.util.ArrayList;
  11. import java.util.Arrays;
  12. import java.util.List;
  13.  
  14. /**
  15.  * @Classname EsClient
  16.  * @Description es的客户端连接
  17.  * @Date 2021/6/3 9:24
  18.  * @Created by gangye
  19.  */
  20. public class EsClient {
  21.     public static String hosts;
  22.  
  23.     public static int connectTimeout;
  24.  
  25.     public static int socketTimeout;
  26.  
  27.     public static int maxRetryTimeout;
  28.  
  29.     public static int connRequestTimeOut;
  30.  
  31.     private static RestHighLevelClient restHighLevelClient = null;
  32.  
  33.     public EsClient(){
  34.         EsClientConfig esClientConfig = new EsClientConfig();
  35.         hosts = esClientConfig.getHosts();
  36.         connectTimeout = esClientConfig.getConnectTimeout();
  37.         socketTimeout = esClientConfig.getSocketTimeout();
  38.         maxRetryTimeout = esClientConfig.getMaxRetryTimeout();
  39.         connRequestTimeOut = esClientConfig.getConnRequestTimeOut();
  40.     }
  41.  
  42.     public static RestHighLevelClient getInstance(){
  43.         if (restHighLevelClient == null){
  44.             synchronized (RestHighLevelClient.class){
  45.                 restHighLevelClient = createClient();
  46.             }
  47.         }
  48.         return restHighLevelClient;
  49.     }
  50.  
  51.     private static RestHighLevelClient createClient(){
  52.         List<String> sockets = Arrays.asList(hosts.split(DefineConstant.COMMAN_SIGN));
  53.         List<HttpHost> httpHosts = new ArrayList<>();
  54.         for (String socket : sockets){
  55.             httpHosts.add(new HttpHost(socket.split(DefineConstant.COLON_SIGN)[0], Integer.valueOf(socket.split(DefineConstant.COLON_SIGN)[1]),"http"));
  56.         }
  57.         RestClientBuilder builder = RestClient.builder(httpHosts.toArray(new HttpHost[0])).setMaxRetryTimeoutMillis(maxRetryTimeout);
  58.         builder.setRequestConfigCallback((RequestConfig.Builder requestConfigBuilder) -> {
  59.             requestConfigBuilder.setConnectTimeout(connectTimeout);
  60.             requestConfigBuilder.setConnectionRequestTimeout(connRequestTimeOut);
  61.             requestConfigBuilder.setSocketTimeout(socketTimeout);
  62.             return requestConfigBuilder;
  63.         });
  64.  
  65.         restHighLevelClient = new RestHighLevelClient(builder);
  66.         return restHighLevelClient;
  67.     }
  68. }

 定义常量值

  1. package com.csrcb.common;
  2.  
  3. /**
  4.  * @Classname DefineConstant
  5.  * @Description 定义一些常量值
  6.  * @Date 2021/6/3 10:00
  7.  * @Created by gangye
  8.  */
  9. public class DefineConstant {
  10.     /**
  11.      * 逗号分隔符
  12.      */
  13.     public static final String COMMAN_SIGN = ",";
  14.  
  15.     /**
  16.      * 等号分隔符
  17.      */
  18.     public static final String EQUALITY_SIGN = "=";
  19.  
  20.     /**
  21.      * 冒号分隔符
  22.      */
  23.     public static final String COLON_SIGN = ":";
  24.  
  25.     /**
  26.      * es的索引文档类型
  27.      */
  28.     public static final String SEARCH_REQUEST_TYPE = "csrcb";
  29.  
  30.     //区间左闭
  31.     public static final String INTERVAL_CLOSE_LEFT = "[";
  32.     //区间右闭
  33.     public static final String INTERVAL_CLOSE_RIGHT = "]";
  34.     //区间左开
  35.     public static final String INTERVAL_OPEN_LEFT = "(";
  36.     //区间右开
  37.     public static final String INTERVAL_OPEN_RIGHT = ")";
  38.  
  39.     public static final String INTERVAL_OPEN_VALUE = "open";
  40.  
  41.     public static final String INTERVAL_CLOSE_VALUE = "close";
  42.  
  43.     public static final String ZERP_MONEY = "0.00";
  44. }

 查询的工具类，支持多条件等值查询，区间范围查询，模糊查询

  1.     /**
  2.      * @Description ElasticSearch条件查询
  3.      * @param tableName       (索引名)也可以类似的说成表名
  4.      * @param equalsCondition 关键字等值条件
  5.      *                        若是一个字符串以%结尾，则匹配以去掉%的字符串开头的记录
  6.      *                        若是一个字符串以*开头或结尾，则模糊匹配去掉*的记录  类似于sql中的like '%str%'
  7.      *                        若传入的是一个普通的字符串，则等值查询
  8.      *                        若传入的是一个集合，则使用的是in条件查询
  9.      * @param rangeCondition  条件范围查询
  10.      *                        字段，字段对应值的区间，区间格式[,]/(,)/[,)/(,]，逗号的左右可以没值
  11.      * @param orderBy         排序字段
  12.      *                        若是字段以中划线-开头，则使用降序排序，类似于sql中的desc
  13.      *                        若正常字段排序，则使用增序排序，类似于sql中的asc
  14.      * @param pageNum         页数
  15.      * @param pageSize        每页大小
  16.      * @return
  17.      */
  18.     public static Map<String ,Object> queryForEs(String tableName, Map<String, Object> equalsCondition, Map<String, Object> rangeCondition, List<String> orderBy, int pageNum, int pageSize){
  19.         Map<String, Object> resultMap = new HashMap<>(8);
  20.         List<Map<String,Object>> queryResult = new ArrayList<>();
  21.         long totalNum = 0;
  22.         SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
  23.         BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
  24.         // and 等值查询
  25.         // 某一field=具体的值； 也可以某一field 的值 in 具体定义集合里的值
  26.         if (null != equalsCondition && !equalsCondition.isEmpty()){
  27.             for (Map.Entry<String ,Object> entry : equalsCondition.entrySet()){
  28.                 String key = entry.getKey();
  29.                 //由于我创建索引的时候使用字符串不分词使用的.keyword类型
  30.                 if (key.endsWith("_s")){
  31.                     queryValueBuild(boolQueryBuilder, key + ".keyword", entry.getValue());
  32.                 }else{
  33.                     queryValueBuild(boolQueryBuilder, key, entry.getValue());
  34.                 }
  35.             }
  36.         }
  37.         //范围查询
  38.         if (null != rangeCondition && !rangeCondition.isEmpty()){
  39.             rangeValueBuild(boolQueryBuilder, rangeCondition);
  40.         }
  41.         sourceBuilder.query(boolQueryBuilder);
  42.         //排序
  43.         if (null != orderBy && !orderBy.isEmpty()){
  44.             buildSort(sourceBuilder, orderBy);
  45.         }
  46.         //分页(es分页查询默认是查询返回10条记录，而深度分页，默认是10000条数据,也就是一次性最多返回10000条,设置size就可以实现，但是如果实际数据量特别大，可以使用scroll游标查询，此处主要常规分页查询)
  47.         if (pageNum > 0){
  48.             sourceBuilder.from(pageSize * (pageNum - 1));
  49.         } else {
  50.             sourceBuilder.from(0);
  51.         }
  52.         sourceBuilder.size(pageSize);
  53.  
  54.         //执行查询
  55.         SearchResponse response = executeSearch(tableName, sourceBuilder);
  56.         SearchHits searchHits = response.getHits();
  57.         SearchHit[] hits = searchHits.getHits();
  58.         totalNum = searchHits.getTotalHits();
  59.         for (int i = 0; i < hits.length; i++){
  60.             SearchHit hit = hits[i];
  61.             Map<String, Object> sourceMap= hit.getSourceAsMap();
  62.             sourceMap.put("id_s", hit.getId());
  63.             queryResult.add(sourceMap);
  64.         }
  65.         resultMap.put("pageList", queryResult);
  66.         resultMap.put("totalNum", totalNum);
  67.         resultMap.put("pageNum", pageNum);
  68.         resultMap.put("pageSize", pageSize);
  69.         return resultMap;
  70.     }
  71.  
  72.     /**
  73.      * @Description 查询条件组装
  74.      * @param boolQueryBuilder
  75.      * @param key
  76.      * @param value
  77.      */
  78.     private static void queryValueBuild(BoolQueryBuilder boolQueryBuilder, String key, Object value){
  79.         TermQueryBuilder termQueryBuilder;
  80.         if (null != value && !"".equals(value)){
  81.             if (value instanceof String){
  82.                 String strValue = (String) value;
  83.                 if (strValue.endsWith("%")){
  84.                     PrefixQueryBuilder prefixQueryBuilder = QueryBuilders.prefixQuery(key,strValue.replace("%",""));
  85.                     boolQueryBuilder.must(prefixQueryBuilder);
  86.                 }else if (strValue.startsWith("*") || strValue.endsWith("*")){
  87.                     MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery(key, strValue.replace("*",""));
  88.                     boolQueryBuilder.must(matchQueryBuilder);
  89.                 }else {
  90.                     termQueryBuilder = QueryBuilders.termQuery(key, strValue);
  91.                     boolQueryBuilder.must(termQueryBuilder);
  92.                 }
  93.             } else if (value instanceof Collection){
  94.                 Collection<? extends Object> collectionValue = (Collection<? extends Object>) value;
  95.                 //此处使用了多值条件
  96.                 boolQueryBuilder.must(QueryBuilders.termsQuery(key, collectionValue));
  97.             } else {
  98.                 termQueryBuilder = QueryBuilders.termQuery(key, value);
  99.                 boolQueryBuilder.must(termQueryBuilder);
  100.             }
  101.         }
  102.     }
  103.  
  104.     /**
  105.      * @Description 范围条件查询组装
  106.      * @param boolQueryBuilder
  107.      * @param rangeCondition
  108.      */
  109.     private static void rangeValueBuild(BoolQueryBuilder boolQueryBuilder, Map<String, Object> rangeCondition){
  110.         for (Map.Entry<String, Object> entry : rangeCondition.entrySet()){
  111.             Map<String, Object> range = intervalParse((String) entry.getValue());
  112.             String key = entry.getKey();
  113.             RangeQueryBuilder rangeQueryBuilder;
  114.             if (key.endsWith("_s")){
  115.                 rangeQueryBuilder = QueryBuilders.rangeQuery(key + ".keyword");
  116.             }else {
  117.                 rangeQueryBuilder = QueryBuilders.rangeQuery(key);
  118.             }
  119.             if (!StringUtils.isEmpty(range.get("leftValue"))){
  120.                 if (DefineConstant.INTERVAL_OPEN_VALUE.equals(range.get("leftType"))){
  121.                     rangeQueryBuilder.from(range.get("leftValue"),false);
  122.                 } else if (DefineConstant.INTERVAL_CLOSE_VALUE.equals(range.get("leftType"))){
  123.                     rangeQueryBuilder.from(range.get("leftValue"),true);
  124.                 }
  125.             }
  126.             if (!StringUtils.isEmpty(range.get("rightValue"))){
  127.                 if (DefineConstant.INTERVAL_OPEN_VALUE.equals(range.get("rightType"))){
  128.                     rangeQueryBuilder.to(range.get("rightValue"),false);
  129.                 } else if (DefineConstant.INTERVAL_CLOSE_VALUE.equals(range.get("rightType"))){
  130.                     rangeQueryBuilder.to(range.get("rightValue"),true);
  131.                 }
  132.             }
  133.             boolQueryBuilder.must(rangeQueryBuilder);
  134.         }
  135.     }
  136.  
  137.     /**
  138.      * @Description 区间解析：[,]/(,)/[,)/(,]
  139.      * @param interval
  140.      * @return
  141.      */
  142.     private static Map<String, Object> intervalParse(String interval){
  143.         Map<String, Object> range = new HashMap<>();
  144.         if (interval.startsWith(DefineConstant.INTERVAL_CLOSE_LEFT)){
  145.             range.put("leftType", DefineConstant.INTERVAL_CLOSE_VALUE);
  146.         } else if (interval.startsWith(DefineConstant.INTERVAL_OPEN_LEFT)){
  147.             range.put("leftType", DefineConstant.INTERVAL_OPEN_VALUE);
  148.         } else{
  149.             log.error("区间参数格式错误：{}",interval);
  150.             //若实际业务相关需要，抛出异常处理throw new Exception();
  151.         }
  152.         if (interval.endsWith(DefineConstant.INTERVAL_CLOSE_RIGHT)){
  153.             range.put("rightType", DefineConstant.INTERVAL_CLOSE_VALUE);
  154.         } else if (interval.startsWith(DefineConstant.INTERVAL_OPEN_RIGHT)){
  155.             range.put("rightType", DefineConstant.INTERVAL_OPEN_VALUE);
  156.         } else{
  157.             log.error("区间参数格式错误：{}",interval);
  158.             //若实际业务相关需要，抛出异常处理throw new Exception();
  159.         }
  160.         int strLen = interval.length();
  161.         String[] lr = interval.substring(1, strLen - 1).split(DefineConstant.COMMAN_SIGN, 2);
  162.         if (lr.length > 0){
  163.             range.put("leftValue", lr[0]);
  164.         }
  165.         if (lr.length > 1){
  166.             range.put("rightValue", lr[1]);
  167.         }
  168.         return range;
  169.     }
  170.  
  171.     /**
  172.      * @Description 查询排序
  173.      * @param sourceBuilder
  174.      * @param orderBy
  175.      */
  176.     private static void buildSort(SearchSourceBuilder sourceBuilder, List<String> orderBy){
  177.         SortBuilder<FieldSortBuilder> sortBuilder;
  178.         for (String sortField : orderBy){
  179.             if (sortField.startsWith("-")){
  180.                 //降序排序
  181.                 if (sortField.endsWith("_s")){
  182.                     sortBuilder = SortBuilders.fieldSort(sortField.replace("-","") + ".keyword").order(SortOrder.DESC);
  183.                 } else {
  184.                     sortBuilder = SortBuilders.fieldSort(sortField.replace("-","")).order(SortOrder.DESC);
  185.                 }
  186.             } else {
  187.                 //升序排序
  188.                 if (sortField.endsWith("_s")){
  189.                     sortBuilder = SortBuilders.fieldSort(sortField.replace("-","") + ".keyword").order(SortOrder.ASC);
  190.                 } else {
  191.                     sortBuilder = SortBuilders.fieldSort(sortField.replace("-","")).order(SortOrder.ASC);
  192.                 }
  193.             }
  194.             sourceBuilder.sort(sortBuilder);
  195.         }
  196.     }
  197.  
  198.     /**
  199.      * @Description 执行查询
  200.      * @param tableName 对应的es的index名
  201.      * @param sourceBuilder
  202.      * @return
  203.      */
  204.     private static SearchResponse executeSearch(String tableName, SearchSourceBuilder sourceBuilder){
  205.         // 获取不同系统的换行符
  206.         String lineSeparator = System.lineSeparator();
  207.         log.info(lineSeparator + "index:" + tableName + lineSeparator + "search:"+ sourceBuilder.toString() + lineSeparator);
  208.         RestHighLevelClient client = EsClient.getInstance();
  209.         SearchRequest searchRequest = new SearchRequest(tableName);
  210.         SearchResponse response = null;
  211.         //设置查询的文档代表的对象的类，即type(此处我写死固定值，可以自行定义)
  212.         searchRequest.types(DefineConstant.SEARCH_REQUEST_TYPE);
  213.         searchRequest.source(sourceBuilder);
  214.         try {
  215.             response = client.search(searchRequest, RequestOptions.DEFAULT);
  216.             log.info("search status:{}, totalNum:{}",response.status(), response.getHits().getTotalHits());
  217.         } catch (IOException e) {
  218.             //异常处理，实际业务中是需要根据需求具体处理，自定义异常捕获
  219.             log.error(e.getMessage());
  220.         }
  221.         return response;
  222.     }

例如查询trade_info索引中客户号为10005，交易金额在200以内(包含200)的记录，并按交易时间倒序排序查询

 控制台打印以及查询结果

而通过工具查询的记录：

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Cpp五条/article/detail/68062
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号