SpringBoot整合Elasticsearch7基于RestHighLevelClient工具类(分页，高亮)

约定不等于承诺〃 2021-09-01 07:00 913阅读 0赞

1.主要依赖

  1. <!-- https://mvnrepository.com/artifact/cn.hutool/hutool-all -->
  2.         <dependency>
  3.             <groupId>cn.hutool</groupId>
  4.             <artifactId>hutool-all</artifactId>
  5.             <version>5.3.10</version>
  6.         </dependency>
  8.         <dependency>
  9.             <groupId>commons-lang</groupId>
  10.             <artifactId>commons-lang</artifactId>
  11.             <version>2.6</version>
  12.         </dependency>
  14.         <!--返回json字符窜的支持 -->
  15.         <dependency>
  16.             <groupId>com.alibaba</groupId>
  17.             <artifactId>fastjson</artifactId>
  18.             <version>1.2.58</version>
  19.         </dependency>
  20.         <!--elasticsearch-->
  21.         <dependency>
  22.             <groupId>org.springframework.boot</groupId>
  23.             <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
  24.         </dependency>

简单配置

  1. @Configuration
  2. public class ElasticsearchConfig { 
  4.     @Bean
  5.     public RestHighLevelClient restHighLevelClient(){ 
  6.         RestHighLevelClient client=new RestHighLevelClient(
  7.                 RestClient.builder(new HttpHost("127.0.0.1",9200,"http")));
  8.         return client;
  9.     }
  11. }

2.查询条件QueryBuilder的构建方法举例

在使用聚合查询之前我们有必要先来了解下创建查询条件QueryBuilder的几种常用方法

2.1精确查询（必须完全匹配上）

  1. 单个匹配termQuery
  3. //不分词查询 参数1： 字段名，参数2：字段查询值，因为不分词，所以汉字只能查询一个字，英语是一个单词.
  4. QueryBuilder queryBuilder=QueryBuilders.termQuery("fieldName", "fieldlValue");
  5. //分词查询，采用默认的分词器
  6. QueryBuilder queryBuilder2 = QueryBuilders.matchQuery("fieldName", "fieldlValue");
  8. 多个匹配
  9. //不分词查询，参数1： 字段名，参数2：多个字段查询值,因为不分词，所以汉字只能查询一个字，英语是一个单词.
  10. QueryBuilder queryBuilder=QueryBuilders.termsQuery("fieldName", "fieldlValue1","fieldlValue2...");
  11. //分词查询，采用默认的分词器
  12. QueryBuilder queryBuilder= QueryBuilders.multiMatchQuery("fieldlValue", "fieldName1", "fieldName2", "fieldName3");
  13. //匹配所有文件，相当于就没有设置查询条件
  14. QueryBuilder queryBuilder=QueryBuilders.matchAllQuery();

2.2模糊查询（只要包含即可）

  1. //模糊查询常见的5个方法如下
  2.         //1.常用的字符串查询
  3.         QueryBuilders.queryStringQuery("fieldValue").field("fieldName");//左右模糊
  4.         //2.常用的用于推荐相似内容的查询
  5.         QueryBuilders.moreLikeThisQuery(new String[] { "fieldName"}).addLikeText("pipeidhua");//如果不指定filedName，则默认全部，常用在相似内容的推荐上
  6.         //3.前缀查询 如果字段没分词，就匹配整个字段前缀
  7.         QueryBuilders.prefixQuery("fieldName","fieldValue");
  8.         //4.fuzzy query:分词模糊查询，通过增加fuzziness模糊属性来查询,如能够匹配hotelName为tel前或后加一个字母的文档，fuzziness 的含义是检索的term 前后增加或减少n个单词的匹配查询
  9.         QueryBuilders.fuzzyQuery("hotelName", "tel").fuzziness(Fuzziness.ONE);
  10.         //5.wildcard query:通配符查询，支持* 任意字符串；？任意一个字符
  11.         QueryBuilders.wildcardQuery("fieldName","ctr*");//前面是fieldname，后面是带匹配字符的字符串
  12.         QueryBuilders.wildcardQuery("fieldName","c?r?");

2.3范围查询

  1. //闭区间查询
  2.         QueryBuilder queryBuilder0 = QueryBuilders.rangeQuery("fieldName").from("fieldValue1").to("fieldValue2");
  3.         //开区间查询
  4.         QueryBuilder queryBuilder1 = QueryBuilders.rangeQuery("fieldName").from("fieldValue1").to("fieldValue2").includeUpper(false).includeLower(false);//默认是true，也就是包含
  5.         //大于
  6.         QueryBuilder queryBuilder2 = QueryBuilders.rangeQuery("fieldName").gt("fieldValue");
  7.         //大于等于
  8.         QueryBuilder queryBuilder3 = QueryBuilders.rangeQuery("fieldName").gte("fieldValue");
  9.         //小于
  10.         QueryBuilder queryBuilder4 = QueryBuilders.rangeQuery("fieldName").lt("fieldValue");
  11.         //小于等于
  12.         QueryBuilder queryBuilder5 = QueryBuilders.rangeQuery("fieldName").lte("fieldValue");

2.4组合查询/多条件查询/布尔查询

  1. QueryBuilders.boolQuery()
  2. QueryBuilders.boolQuery().must();//文档必须完全匹配条件，相当于and
  3. QueryBuilders.boolQuery().mustNot();//文档必须不匹配条件，相当于not
  4. QueryBuilders.boolQuery().should();//至少满足一个条件，这个文档就符合should，相当于or

3.工具类

  1. /** * @Author: dxf * @Description: Elasticsearch工具类 * @Date: Created in 2020-08-22 17:49 * @Modified By: */
  2. @Component
  3. @Slf4j
  4. public class ElasticsearchUtil { 
  5.     //最好不要自定义id 会影响插入速度。
  7.     @Autowired
  8.     @Qualifier("restHighLevelClient")
  9.     private  RestHighLevelClient restHighLevelClient;
  11.     /** * 创建索引 * @param index * @return */
  12.     public  boolean createIndex(String index) throws IOException { 
  13.         if(isIndexExist(index)){ 
  14.             log.error("Index is exits!");
  15.             return false;
  16.         }
  17.         //1.创建索引请求
  18.         CreateIndexRequest request = new CreateIndexRequest(index);
  19.         //2.执行客户端请求
  20.         org.elasticsearch.client.indices.CreateIndexResponse response = restHighLevelClient.indices()
  21.                 .create(request, RequestOptions.DEFAULT);
  22.         return response.isAcknowledged();
  23.     }
  25.     /** * 判断索引是否存在 * @param index * @return */
  26.     public  boolean isIndexExist(String index) throws IOException { 
  27.         GetIndexRequest request = new GetIndexRequest(index);
  28.         boolean exists = restHighLevelClient.indices().exists(request, RequestOptions.DEFAULT);
  29.         return exists;
  30.     }
  32.     /** * 删除索引 * @param index * @return */
  33.     public  boolean deleteIndex(String index) throws IOException { 
  34.         if(!isIndexExist(index)) { 
  35.             log.error("Index is not exits!");
  36.             return false;
  37.         }
  38.         DeleteIndexRequest request = new DeleteIndexRequest(index);
  39.         AcknowledgedResponse delete = restHighLevelClient.indices()
  40.                 .delete(request, RequestOptions.DEFAULT);
  41.         return delete.isAcknowledged();
  42.     }
  44.     /** * 数据添加，自定义id * @param object 要增加的数据 * @param index 索引，类似数据库 * @param id 数据ID,为null时es随机生成 * @return */
  45.     public  String addData(Object object, String index, String id) throws IOException { 
  46.         //创建请求
  47.         IndexRequest request = new IndexRequest(index);
  48.         //规则 put /test_index/_doc/1
  49.         request.id(id);
  50.         request.timeout(TimeValue.timeValueSeconds(1));
  51.         //将数据放入请求 json
  52.         IndexRequest source = request.source(JSON.toJSONString(object), XContentType.JSON);
  53.         //客户端发送请求
  54.         IndexResponse response = restHighLevelClient.index(request, RequestOptions.DEFAULT);
  55.         return response.getId();
  56.     }
  58.     /** * 数据添加 随机id * @param object 要增加的数据 * @param index 索引，类似数据库 * @return */
  59.     public  String addData(Object object, String index) throws IOException { 
  60.         return addData(object, index, UUID.randomUUID().toString().replaceAll("-", "").toUpperCase());
  61.     }
  63.     /** * 通过ID删除数据 * @param index 索引，类似数据库 * @param id 数据ID * @return */
  64.     public  void deleteDataById(String index,String id) throws IOException { 
  65.         DeleteRequest request = new DeleteRequest(index, id);
  66.         restHighLevelClient.delete(request, RequestOptions.DEFAULT);
  67.     }
  69.     /** * 通过ID 更新数据 * @param object 要更新数据 * @param index 索引，类似数据库 * @param id 数据ID * @return */
  70.     public  void updateDataById(Object object, String index, String id) throws IOException { 
  71.         UpdateRequest update = new UpdateRequest(index, id);
  72.         update.timeout("1s");
  73.         update.doc(JSON.toJSONString(object), XContentType.JSON);
  74.         restHighLevelClient.update(update, RequestOptions.DEFAULT);
  75.     }
  77.     /** * 通过ID获取数据 * @param index 索引，类似数据库 * @param id 数据ID * @param fields 需要显示的字段，逗号分隔（缺省为全部字段） * @return */
  78.     public  Map<String,Object> searchDataById(String index, String id, String fields) throws IOException { 
  79.         GetRequest request = new GetRequest(index, id);
  80.         if (StringUtils.isNotEmpty(fields)){ 
  81.             //只查询特定字段。如果需要查询所有字段则不设置该项。
  82.             request.fetchSourceContext(new FetchSourceContext(true,fields.split(","), Strings.EMPTY_ARRAY));
  83.         }
  84.         GetResponse response = restHighLevelClient.get(request, RequestOptions.DEFAULT);
  85.         return response.getSource();
  86.     }
  88.     /** * 通过ID判断文档是否存在 * @param index 索引，类似数据库 * @param id 数据ID * @return */
  89.     public  boolean existsById(String index,String id) throws IOException { 
  90.         GetRequest request = new GetRequest(index, id);
  91.         //不获取返回的_source的上下文
  92.         request.fetchSourceContext(new FetchSourceContext(false));
  93.         request.storedFields("_none_");
  94.         return restHighLevelClient.exists(request, RequestOptions.DEFAULT);
  95.     }
  97.     /** * 批量插入false成功 * @param index 索引，类似数据库 * @param objects 数据 * @return */
  98.     public  boolean bulkPost(String index, List<?> objects) { 
  99.         BulkRequest bulkRequest = new BulkRequest();
  100.         BulkResponse response=null;
  101.         //最大数量不得超过20万
  102.         for (Object object: objects) { 
  103.             IndexRequest request = new IndexRequest(index);
  104.             request.source(JSON.toJSONString(object), XContentType.JSON);
  105.             bulkRequest.add(request);
  106.         }
  107.         try { 
  108.             response=restHighLevelClient.bulk(bulkRequest,RequestOptions.DEFAULT);
  109.         } catch (IOException e) { 
  110.             e.printStackTrace();
  111.         }
  112.         return response.hasFailures();
  113.     }
  115.     /** * 根据经纬度查询范围查找location 经纬度字段，distance 距离中心范围KM，lat lon 圆心经纬度 * @param index * @param longitude * @param latitude * @param distance * @return */
  116.     public  SearchResponse geoDistanceQuery(String index,Float  longitude, Float latitude,String distance) throws IOException { 
  118.         if(longitude == null || latitude == null){ 
  119.             return null;
  120.         }
  121.         //拼接条件
  122.         BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
  123. // QueryBuilder isdeleteBuilder = QueryBuilders.termQuery("isdelete", false);
  124.         // 以某点为中心，搜索指定范围
  125.         GeoDistanceQueryBuilder distanceQueryBuilder = new GeoDistanceQueryBuilder("location");
  126.         distanceQueryBuilder.point(latitude, longitude);
  127.         //查询单位：km
  128.         distanceQueryBuilder.distance(distance, DistanceUnit.KILOMETERS);
  129.         boolQueryBuilder.filter(distanceQueryBuilder);
  130. // boolQueryBuilder.must(isdeleteBuilder);
  132.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  133.         searchSourceBuilder.query(boolQueryBuilder);
  135.         SearchRequest searchRequest = new SearchRequest(index);
  136.         searchRequest.source(searchSourceBuilder);
  138.         SearchResponse searchResponse = restHighLevelClient.search(searchRequest,RequestOptions.DEFAULT);
  139.         return searchResponse;
  140.     }
  142.     /** * 获取低水平客户端 * @return */
  143.     public RestClient getLowLevelClient() { 
  144.         return restHighLevelClient.getLowLevelClient();
  145.     }
  147.     /** * 高亮结果集 特殊处理 * map转对象 JSONObject.parseObject(JSONObject.toJSONString(map), Content.class) * @param searchResponse * @param highlightField */
  148.     private  List<Map<String, Object>> setSearchResponse(SearchResponse searchResponse, String highlightField) { 
  149.         //解析结果
  150.         ArrayList<Map<String,Object>> list = new ArrayList<>();
  151.         for (SearchHit hit : searchResponse.getHits().getHits()) { 
  152.             Map<String, HighlightField> high = hit.getHighlightFields();
  153.             HighlightField title = high.get(highlightField);
  154.             Map<String, Object> sourceAsMap = hit.getSourceAsMap();//原来的结果
  155.             //解析高亮字段,将原来的字段换为高亮字段
  156.             if (title!=null){ 
  157.                 Text[] texts = title.fragments();
  158.                 String nTitle="";
  159.                 for (Text text : texts) { 
  160.                     nTitle+=text;
  161.                 }
  162.                 //替换
  163.                 sourceAsMap.put(highlightField,nTitle);
  164.             }
  165.             list.add(sourceAsMap);
  166.         }
  167.         return list;
  168.     }
  170.     /** * 查询并分页 * @param index 索引名称 * @param query 查询条件 * @param size 文档大小限制 * @param fields 需要显示的字段，逗号分隔（缺省为全部字段） * @param sortField 排序字段 * @param highlightField 高亮字段 * @return */
  171.     public  List<Map<String, Object>> searchListData(String index,
  172.                                                      SearchSourceBuilder query,
  173.                                                      Integer size,
  174.                                                      Integer from,
  175.                                                      String fields,
  176.                                                      String sortField,
  177.                                                      String highlightField) throws IOException { 
  178.         SearchRequest request = new SearchRequest(index);
  179.         SearchSourceBuilder builder = query;
  180.         if (StringUtils.isNotEmpty(fields)){ 
  181.             //只查询特定字段。如果需要查询所有字段则不设置该项。
  182.             builder.fetchSource(new FetchSourceContext(true,fields.split(","),Strings.EMPTY_ARRAY));
  183.         }
  184.         from = from <= 0 ? 0 : from*size;
  185.         //设置确定结果要从哪个索引开始搜索的from选项，默认为0
  186.         builder.from(from);
  187.         builder.size(size);
  188.         if (StringUtils.isNotEmpty(sortField)){ 
  189.             //排序字段，注意如果proposal_no是text类型会默认带有keyword性质，需要拼接.keyword
  190.             builder.sort(sortField+".keyword", SortOrder.ASC);
  191.         }
  192.         //高亮
  193.         HighlightBuilder highlight = new HighlightBuilder();
  194.         highlight.field(highlightField);
  195.         //关闭多个高亮
  196.         highlight.requireFieldMatch(false);
  197.         highlight.preTags("<span style='color:red'>");
  198.         highlight.postTags("</span>");
  199.         builder.highlighter(highlight);
  200.         //不返回源数据。只有条数之类的数据。
  201. // builder.fetchSource(false);
  202.         request.source(builder);
  203.         SearchResponse response = restHighLevelClient.search(request, RequestOptions.DEFAULT);
  204.         log.error("=="+response.getHits().getTotalHits());
  205.         if (response.status().getStatus() == 200) { 
  206.             // 解析对象
  207.             return setSearchResponse(response, highlightField);
  208.         }
  209.         return null;
  210.     }
  211. }

发表评论

表情：
评论列表 （有 0 条评论，913人围观）

还没有评论，来说两句吧...

相关阅读