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

SpringBoot集成ElasticSearch 7.9.2 教程和简单增删改查案例（基于ElasticsearchRestTemplate）_org.elasticsearch.index.versiontype

作者：weixin_40725706 | 2024-04-07 03:09:10

赞

踩

org.elasticsearch.index.versiontype

本文只做springboot与es的集成和简单API操作，若想了解es的基础概念和其他知识点，请移步官方网站：开源搜索：Elasticsearch、ELK Stack 和 Kibana 的开发者 | Elastic；

推荐一篇es学习的博客：狂神elasticsearch笔记(纯手敲)_哦到凯呀的博客-CSDN博客_狂神说elasticsearch笔记

通用的工具请自取：

SpringBoot基于ElasticSearch7.9.2和ElasticsearchRestTemplate的一些通用接口（可复用）_菜菜的小咸鱼的博客-CSDN博客 

另外，es的更新非常快，目前官网最新的版本已经到7.13了，每个版本的API可能都会有所改动。

本文基于SpringBoot 2.3.1.RELEASE，ES 7.9.2做演示。

开始吧！

首先，肯定要先安装es,kibana，基础的安装步骤、配置、分词器插件配置，这里就不在介绍，百度一搜一大把。

  • 一、pom引入spring-data-elasticsearch
  1. <dependency>
  2.      <groupId>org.springframework.boot</groupId>
  3.      <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
  4. </dependency>

注意：不同版本spring-data对应的es的默认配置版本不一样，如：我当前使用的spring-data 版本为4.0，其中默认的es版本为7.6.2，因此我们需要自己指定需要使用的es版本。

在我们项目的pom.xml里面指定es的版本：

  • 二、配置连接参数

1、yml配置文件（主要是为了方便修改），注意这里的缩进，因为没有使用spring自带的es配置，所以节点名称都可以自定义，同时父节点为一级节点。

  1. elasticsearch:
  2.   scheme: http
  3.   host: localhost 
  4.   port: 9200
  5.   connection-request-timeout: 30000
  6.   socket-timeout: 6000000
  7.   connect-timeout: 5000000

如果使用spring的es配置，格式如下：

  1. spring:
  2.     data:
  3.       elasticsearch:
  4.         xxxx:zzzz
  5.         xxxx:zzzz

 2、新建配置文件读取配置客户端连接。

  1. import org.apache.http.HttpHost;
  2. import org.elasticsearch.client.RestClient;
  3. import org.elasticsearch.client.RestHighLevelClient;
  4. import org.springframework.beans.factory.annotation.Qualifier;
  5. import org.springframework.beans.factory.annotation.Value;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8.  
  9.  
  10. @Configuration
  11. public class ElasticSearchClientConfig {
  12.  
  13.     @Value("${elasticsearch.host}")
  14.     private String host;
  15.  
  16.     @Value("${elasticsearch.port}")
  17.     private Integer port;
  18.  
  19.     @Value("${elasticsearch.scheme}")
  20.     private String scheme;
  21.  
  22.     @Value("${elasticsearch.connect-timeout}")
  23.     private Integer connectTimeout;
  24.  
  25.     @Value("${elasticsearch.socket-timeout}")
  26.     private Integer socketTimeout;
  27.  
  28.     @Bean
  29.     @Qualifier("highLevelClient")
  30.     public RestHighLevelClient restHighLevelClient() {
  31.         // 该方法接收一个RequestConfig.Builder对象，对该对象进行修改后然后返回。
  32.         RestHighLevelClient highLevelClient = new RestHighLevelClient(
  33.                 RestClient.builder(new HttpHost(host, port, scheme))
  34.                         .setRequestConfigCallback(requestConfigBuilder -> {
  35.                             return requestConfigBuilder.setConnectTimeout(connectTimeout) // 连接超时（默认为1秒）
  36.                                     .setSocketTimeout(socketTimeout);// 套接字超时（默认为30秒）//更改客户端的超时限制默认30秒现在改为100*1000分钟
  37.                         }));// 调整最大重试超时时间（默认为30秒）.setMaxRetryTimeoutMillis(60000);
  38.  
  39.         return highLevelClient;
  40.     }
  41. }

至此，springboot配置es就完成了，启动项目即可看到如下信息：因为我们设置了版本和springdata默认的版本一直，所以会警告版本不匹配，不用理会。

  • 三、新建一个实体类，并配置索引映射，这样我们可以直接用这个类去创建索引，并且配置索引字段的mapping

在创建实体类和映射规则前，有必要先了解一下elasticsearch的几个常用注解和枚举：

1、@Document，位于org.springframework.data.elasticsearch.annotations包下。

  1. @Persistent
  2. @Inherited
  3. @Retention(RetentionPolicy.RUNTIME)
  4. @Target({ ElementType.TYPE })
  5. public @interface Document {
  6.     
  7.     /**
  8. 	 * Name of the Elasticsearch index.
  9. 	 * <ul>
  10. 	 * <li>Lowercase only</li>
  11. 	 * <li><Cannot include \, /, *, ?, ", <, >, |, ` ` (space character), ,, #/li>
  12. 	 * <li>Cannot start with -, _, +</li>
  13. 	 * <li>Cannot be . or ..</li>
  14. 	 * <li>Cannot be longer than 255 bytes (note it is bytes, so multi-byte characters will         
  15.      * count towards the 255 limit
  16. 	 * faster)</li>
  17. 	 * </ul>
  18. 	 */
  19.     String indexName(); //索引名称，好比MySQL的数据库名
  20.  
  21.     @Deprecated
  22. 	String type() default ""; //类型 ,当前版本已弃用
  23.     
  24.     /**
  25. 	 * Use server-side settings when creating the index.
  26.      * 翻译过来就是：创建索引时使用服务器端设置。
  27.      * 这里默认为false,如果改为true,表示在Spring创建索引时，Spring不会在创建的索引中设置以下设            
  28.      * 置：shards、replicas、refreshInterval和indexStoreType。这些设置将是 Elasticsearch 默认 
  29.      * 值（服务器配置），也就是说，我们自定义的某些配置将不会生效。
  30. 	 */
  31. 	boolean useServerConfiguration() default false;
  32.     
  33.     short shards() default 1; // 默认分区数
  34.     
  35.     short replicas() default 1;// 默认每个分区的备份数
  36.     
  37.     String refreshInterval() default "1s"; //索引默认的刷新时间间隔
  38.     
  39.     String indexStoreType() default "fs"; //索引文件存储类型
  40.  
  41.     /**
  42. 	 * Configuration whether to create an index on repository bootstrapping.
  43. 	 */
  44. 	boolean createIndex() default true; //当spring容器启动时，如果索引不存在，则自动创建索引
  45.     
  46.     VersionType versionType() default VersionType.EXTERNAL;//默认的版本管理类型
  47. }

2、@Field，位于org.springframework.data.elasticsearch.annotations包下：这个注解的字段比较多，这里只列举几个比较常用的

  1. @Retention(RetentionPolicy.RUNTIME)
  2. @Target(ElementType.FIELD)
  3. @Documented
  4. @Inherited
  5. public @interface Field {
  6.     /**
  7. 	 * Alias for {@link #name}.
  8. 	 *
  9. 	 * @since 3.2
  10. 	 */
  11. 	@AliasFor("name")
  12. 	String value() default "";
  13.  
  14. 	/**
  15. 	 * The <em>name</em> to be used to store the field inside the document.
  16. 	 * <p>
  17. 	 * √5 If not set, the name of the annotated property is used.
  18. 	 *
  19. 	 * @since 3.2
  20. 	 */
  21. 	@AliasFor("value")
  22. 	String name() default "";
  23.     //上面两个注解，可互为别名使用。
  24.     //主要的作用就是指定我们创建索引时，当前字段在索引中的名称，如果不设置，它会默认使用实体类里    
  25.     // 面使用了@Field这个注解的属性名作为索引字段名。例如：
  26.     // class User{
  27.     //     
  28.     //     @Field(name = "name" * 或者：value = "name"* )
  29.     //     private String userName;
  30.     // }
  31.     // 如上，如果设置了name（或value）值，那么索引里面对应userName的字段名就是“name”，否则就是            
  32.     // “userName”
  33.  
  34.     FieldType type() default FieldType.Auto; //自动检测索引字段的数据类型，可以根据实际情况自己设置。
  35.     
  36.     DateFormat format() default DateFormat.none;//日期时间格式化，默认不做任何处理
  37.     
  38.     String searchAnalyzer() default "";//检索时的分词策略
  39.     
  40.     String analyzer() default "";//创建索引时指定分词策略
  41.     
  42.     .
  43.     .
  44.     .
  45.     
  46. }

3、@Field中提到的FieldType 枚举：

  1. public enum FieldType {
  2.     Auto, //根据内容自动判断
  3.     Text, //索引全文字段，如产品描述。这些字段会被分词器进行分词处理。
  4.     Keyword, //用于索引结构化内容（如电子邮件地址，主机名，状态码，邮政编码等）的字段。他们通常用于过滤、排序、聚合。关键字字段只能根据期确切的值进行搜索。标记为keyword的字段不会被分词器分词处理
  5.     Long, //
  6.     Integer, //
  7.     Short, //
  8.     Byte, //
  9.     Double, //
  10.     Float, //
  11.     Half_Float, //
  12.     Scaled_Float, //
  13.     Date, //
  14.     Date_Nanos, //
  15.     Boolean, //
  16.     Binary, //
  17.     Integer_Range, //
  18.     Float_Range, //
  19.     Long_Range, //
  20.     Double_Range, //
  21.     Date_Range, //
  22.     Ip_Range, //
  23.     Object, //
  24.     Nested, //
  25.     Ip, //可以索引和存储IPV4和IPv6地址
  26.     TokenCount, //
  27.     Percolator, //
  28.     Flattened, //
  29.     Search_As_You_Type //
  30. }

好了，了解了基础的注解之后，新建实体类并映射规则，为创建索引做准备：

  1. @Data //lombok的data注解
  2. @Document(indexName = "my_index")
  3. public class EsSourceInfo  implements Serializable { 
  4.  
  5.     private static final long serialVersionUID = -4780769443664126870L;
  6.  
  7.     @Field(type = FieldType.Keyword) //当前字段不能被分词
  8.     private String lngId;
  9.     
  10.     private String remark; //不加@Field注解，创建索引时会使用默认的Field设置
  11.     
  12.     /**
  13.      * analyzer = "ik_smart" 创建索引使用的分词策略
  14.      * type = FieldType.Text 字段类型为文本类型
  15.      * searchAnalyzer = "ik_max_word" 检索时的分词策略
  16.      */
  17.     @Field(analyzer = "ik_smart",type = FieldType.Text,searchAnalyzer = "ik_max_word")
  18.     private String discreption;
  19.  
  20.     /**
  21.      * analyzer = "ik_max_word" 创建索引使用的分词策略
  22.      * type = FieldType.Text 字段类型为文本类型
  23.      * searchAnalyzer = "ik_smart" 检索时的分词策略
  24.      */
  25.     @Field(analyzer = "ik_max_word",type = FieldType.Text,searchAnalyzer = "ik_smart")
  26.     private String address;
  27.  
  28.     /**
  29.      * type = FieldType.Keyword字段类型为文本类型
  30.      * 这里的keywordsArrays为后期用来做聚类的字段，不会被分词器分词
  31.      */
  32.     @Field(type = FieldType.Keyword)
  33.     private String[] keywordsArrays;
  34. }

上面关于ik分词器的分词策略解释：

 1、ik_max_word：会将文本做最细粒度的拆分，比如会将“中华人民共和国人民大会堂”拆分为“中华人民共和国、中华人民、中华、华人、人民共和国、人民、共和国、大会堂、大会、会堂等词语。

2、ik_smart：会做最粗粒度的拆分，比如会将“中华人民共和国人民大会堂”拆分为中华人民共和国、人民大会堂。

两种分词器使用的最佳实践是：索引时用ik_max_word，在搜索时用ik_smart

  • 四、索引操作
  1. import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
  2. import org.springframework.data.elasticsearch.core.IndexOperations;
  3. import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
  4.  
  5. import java.lang.annotation.Annotation;
  6.  
  7.  
  8. public class IndexOperation {
  9.     
  10.     
  11.     @Autowired
  12.     private ElasticsearchRestTemplate restTemplate;
  13.     
  14.     /**
  15.      * @Description 根据实体类创建索引，这里的实体类就是上面创建的EsSourceInfo实体
  16.      * @Author Innocence
  17.      */
  18.     public Boolean createIndexByClass(Class clazz) {
  19.         Annotation documentAnnotation = clazz.getDeclaredAnnotation(Document.class);
  20.         if(documentAnnotation==null){
  21.             return false;
  22.         }
  23.         String indexName = ((Document) documentAnnotation).indexName();
  24.         Boolean indexExist = isIndexExist(indexName);
  25.         if (indexExist){
  26.             return false;
  27.         }
  28.         IndexOperations indexOps = restTemplate.indexOps(clazz);
  29.         boolean result1 = indexOps.create(); //创建索引
  30.         boolean result2 = indexOps.putMapping(indexOps.createMapping(clazz));/设置索引的映射规则，很重要！！！
  31.         return result1&result2;
  32.     }
  33.  
  34.     /**
  35.      * @Description 根据索引名判断索引是否存在
  36.      * @Author Innocence
  37.      */
  38.     public Boolean isIndexExist(String indexName) {
  39.         IndexOperations indexOps = restTemplate.indexOps(IndexCoordinates.of(indexName));
  40.         return indexOps.exists();
  41.     }
  42.  
  43.     /**
  44.      * @Description 根据索引名删除索引
  45.      * @Author Innocence
  46.      */
  47.     public Boolean deleteIndexByName(String indexName) {
  48.         IndexOperations indexOps = restTemplate.indexOps(IndexCoordinates.of(indexName));
  49.         return indexOps.delete();
  50.  
  51.     }
  52. }
  • 五、文档操作（重点：类似MySQL的CRUD操作）
  1. import com.google.common.collect.Lists;
  2. import org.apache.commons.beanutils.BeanUtils;
  3. import org.apache.commons.beanutils.PropertyUtils;
  4. import org.elasticsearch.action.search.SearchRequest;
  5. import org.elasticsearch.action.search.SearchResponse;
  6. import org.elasticsearch.client.RequestOptions;
  7. import org.elasticsearch.client.RestHighLevelClient;
  8. import org.elasticsearch.index.query.QueryBuilders;
  9. import org.elasticsearch.search.aggregations.Aggregation;
  10. import org.elasticsearch.search.aggregations.Aggregations;
  11. import org.elasticsearch.search.aggregations.bucket.terms.ParsedStringTerms;
  12. import org.elasticsearch.search.aggregations.bucket.terms.Terms;
  13. import org.elasticsearch.search.builder.SearchSourceBuilder;
  14. import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
  15. import org.springframework.beans.factory.annotation.Autowired;
  16. import org.springframework.data.domain.Page;
  17. import org.springframework.data.domain.PageImpl;
  18. import org.springframework.data.domain.PageRequest;
  19. import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
  20. import org.springframework.data.elasticsearch.core.SearchHit;
  21. import org.springframework.data.elasticsearch.core.SearchHits;
  22. import org.springframework.data.elasticsearch.core.document.Document;
  23. import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
  24. import org.springframework.data.elasticsearch.core.query.*;
  25.  
  26. import java.io.IOException;
  27. import java.lang.reflect.InvocationTargetException;
  28. import java.util.ArrayList;
  29. import java.util.HashMap;
  30. import java.util.List;
  31. import java.util.Map;
  32. public class DocumentOperation {
  33.  
  34.     @Autowired
  35.     private ElasticsearchRestTemplate restTemplate;
  36.  
  37.     @Autowired
  38.     private RestHighLevelClient highLevelClient;
  39.  
  40.     /**
  41.      * 映射高亮字段到原生属性,es的高亮查询不会直接把高亮字段映射到实体类，所以这里我们要自己处理
  42.      * @author Innocence
  43.      * @param searchHits
  44.      * @return java.util.List<T>
  45.      */
  46.     private <T> List<T> mappingHighlight(List<SearchHit<T>> searchHits){
  47.         List<T> infoList = Lists.newArrayList();
  48.         for (SearchHit<T> searchHit : searchHits) {
  49.             T content = searchHit.getContent();
  50.             Map<String, List<String>> highlightFields = searchHit.getHighlightFields();
  51.             for (Map.Entry<String, List<String>> entry : highlightFields.entrySet()) {
  52.                 try {
  53.                         PropertyUtils.setProperty(content,entry.getKey(),entry.getValue().get(0));
  54.                 } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
  55.                     e.printStackTrace();
  56.                 }
  57.             }
  58.             infoList.add(content);
  59.         }
  60.         return infoList;
  61.     }
  62.     
  63.     /**
  64.      * 设置高亮映射规则 
  65.      * @author Innocence
  66.      * @date 2021/6/9
  67.      * @param [fields] 
  68.      * @return org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder
  69.      */
  70.     public HighlightBuilder getHighlightBuilder(String[] fields) {
  71.         HighlightBuilder highlightBuilder = new HighlightBuilder();
  72.         for (String field : fields) {
  73.             highlightBuilder.field(field);
  74.         }
  75.         highlightBuilder.requireFieldMatch(false);     //如果要多个字段高亮,这项要为false
  76.         highlightBuilder.preTags("<span style=\"color:red\">");
  77.         highlightBuilder.postTags("</span>");
  78.         //下面这两项,如果你要高亮如文字内容等有很多字的字段,必须配置,不然会导致高亮不全,文章内容缺失等
  79.         highlightBuilder.fragmentSize(800000); //最大高亮分片数
  80.         highlightBuilder.numOfFragments(0); //从第一个分片获取高亮片段
  81.  
  82.         return highlightBuilder;
  83.     }
  84.  
  85.     /**
  86.      * 根据id判断文档是否存在于指定索引中
  87.      * @author Innocence
  88.      * @param id  文档id,这里的id是需要我们在存储数据时指定
  89.      * @param indexName    索引名
  90.      * @return java.lang.Boolean
  91.      */
  92.     public Boolean isExist(String id,String indexName) {
  93.         return restTemplate.exists(id, IndexCoordinates.of(indexName));
  94.     }
  95.     
  96.     /**
  97.      *  单条数据插入
  98.      * @author Innocence
  99.      * @param entity 待插入的数据实体
  100.      * @param indexName 索引名
  101.      * @return java.lang.String 返回文档id
  102.      */
  103.      public String saveByEntity(EsSourceInfo entity, String indexName) throws Exception{
  104.         if (StrUtil.isBlank(entity.getLngId())){
  105.             throw new Exception("文档id不能为空！");
  106.         }
  107.         IndexQuery build = new IndexQueryBuilder()
  108.                 .withId(entity.getLngId()) //这里的操作就是指定文档id
  109.                 .withObject(entity).build();
  110.         return restTemplate.index(build,IndexCoordinates.of(indexName));
  111.     }
  112.     
  113.     /**
  114.      * 批量插入
  115.      * @author Innocence
  116.      * @param entities 待插入的数据实体集合
  117.      * @param indexName 索引名
  118.      * @return java.util.List<java.lang.String> 返回idList
  119.      */
  120.     public List<String> saveBatchByEntities(List<EsSourceInfo> entities, String indexName) throws Exception{
  121.         List<IndexQuery> queryList = new ArrayList<>();
  122.         for (EsSourceInfo item:entities){
  123.             if (StrUtil.isBlank(item.getLngId())){
  124.                 throw new Exception("文档id不能为空！");
  125.             }
  126.             IndexQuery build = new IndexQueryBuilder().withId(item.getLngId()).withObject(item).build();
  127.             queryList.add(build);
  128.         }
  129.         return restTemplate.bulkIndex(queryList, IndexCoordinates.of(indexName));
  130.     }
  131.  
  132.     /**
  133.      * 单条数据更新
  134.      * @author Innocence
  135.      * @param entity 待更新的数据实体
  136.      * @param indexName 索引名
  137.      * @return void
  138.      */
  139.     public void updateByEntity(EsSourceInfo entity, String indexName) {
  140.         Map<String,Object> map = null;
  141.         try {
  142.             map = BeanUtils.describe(entity);
  143.         } catch (Exception e) {
  144.             e.printStackTrace();
  145.         }
  146.         Document document = Document.from(map);
  147.         document.setId(entity.getLngId());
  148.         // 这里的UpdateQuery需要构造一个Document对象，但是Document对象不能用实体类转化而来 
  149.         //（可见Document的源码，位于：org.springframework.data.elasticsearch.core.document 
  150.         // 包下），因此上面才会BeanUtils.describe(entity)，将实体类转化成一个map，由map转化 
  151.         // 为Document对象。
  152.         UpdateQuery build = UpdateQuery.builder(entity.getLngId())
  153.                 .withDocAsUpsert(false) //不加默认false。true表示更新时不存在就插入
  154.                 .withDocument(document)
  155.                 .build();
  156.         restTemplate.update(build, IndexCoordinates.of(indexName));
  157.     }
  158.     
  159.     /**
  160.      * 根据maps批量更新
  161.      * @author Innocence
  162.      * @param maps 待更新的数据实体集合
  163.      * @param indexName 索引名
  164.      * @return void
  165.      */
  166.     public void updateByMaps(List<Map<String, Object>> maps, String indexName) {
  167.         List<UpdateQuery> updateQueries = new ArrayList<>();
  168.         maps.forEach(item->{
  169.             Document document = Document.from(item);
  170.             document.setId(String.valueOf(item.get("lngid")));
  171.             UpdateQuery build = UpdateQuery.builder(document.getId())
  172.                     .withDocument(document)
  173.                     .build();
  174.             updateQueries.add(build);
  175.         });
  176.         restTemplate.bulkUpdate(updateQueries,IndexCoordinates.of(indexName));
  177.     }
  178.  
  179.     /**
  180.      * 根据id删除数据
  181.      * @author Innocence
  182.      * @param id
  183.      * @param indexName 索引名
  184.      * @return java.lang.String 被删除的id
  185.      */
  186.     public String deleteById(String id, String indexName) {
  187.         return restTemplate.delete(id,IndexCoordinates.of(indexName));
  188.     }
  189.     
  190.     /**
  191.      * 根据id批量删除数据
  192.      * @author Innocence
  193.      * @param docIdName 文档id字段名，如我们上面设置的文档id的字段名为“lngId”
  194.      * @param ids 需要删除的id集合
  195.      * @param indexName  索引名称
  196.      * @return void
  197.      */
  198.     public void deleteByIds(String docIdName , List<String> ids, String indexName) {
  199.         StringQuery query = new StringQuery(QueryBuilders.termsQuery(docIdName, ids).toString());
  200.         restTemplate.delete(query,null,IndexCoordinates.of(indexName));
  201.     }
  202.     
  203.     /**
  204.      * 根据条件删除数据
  205.      * @author Innocence
  206.      * @param query 条件构造器
  207.      * @param clazz 数据对应实体类
  208.      * @param indexName 索引名
  209.      * @return void
  210.      */
  211.     public void deleteByQuery(Query query, Class<?> clazz, String indexName) {
  212.         restTemplate.delete(query,clazz,IndexCoordinates.of(indexName));
  213.     }
  214.     
  215.     /**
  216.      * 根据id查询数据 (基于注解形式设置了索引mapping)
  217.      * @param id
  218.      */
  219.     public EsSourceInfo getEntityById(String id) {
  220.         return restTemplate.get(id,EsSourceInfo.class);
  221.     }
  222.  
  223.     /**
  224.      * 查询符合条件的总条数
  225.      * @author Innocence
  226.      * @return java.lang.Long
  227.      */
  228.     public Long getCount(Query query, Class clazz) {
  229.         return restTemplate.count(query,clazz);
  230.     }
  231.     
  232.     /**
  233.      * 查询符合条件的实体list
  234.      * @author Innocence
  235.      * @param query 构建的查询条件 主要使用NativeSearchQuery 来进行构造
  236.      * @return java.util.List<com.cqvip.innocence.project.model.entity.EsSourceInfo>
  237.      */
  238.     public  List<EsSourceInfo> getInfoList(Query query, String indexName) {
  239.         // es本身默认限制了查找的量为10000条,官方文档的建议是不要修改，太大会影响性能和效率，
  240.         // 建议使用 scroll 来代替。如果超出10000条，返回的结果最多只有10000条
  241.         // 所以，我们在这里设置setTrackTotalHits(true)，返回真实的命中条数
  242.         query.setTrackTotalHits(true);
  243.         SearchHits<EsSourceInfo> search = restTemplate.search(query, EsSourceInfo.class, IndexCoordinates.of(indexName));
  244.         return mappingHighlight(search.getSearchHits());//映射的高亮字段
  245.     }
  246.     
  247.     /**
  248.       * 分页查询
  249.       * @author Innocence
  250.       * @param query 构建的查询条件 主要使用NativeSearchQuery 来进行构造
  251.       * @return org.springframework.data.domain.Page<com.cqvip.innocence.project.model.entity.EsSourceInfo>
  252.       */
  253.     public Map<String, Object> getPageList(Query query, PageRequest pageRequest) {
  254.         query.setTrackTotalHits(true);
  255.         SearchHits<EsSourceInfo> search = restTemplate.search(query, EsSourceInfo.class);
  256.         Aggregations aggregations = search.getAggregations();
  257.         List<SearchHit<EsSourceInfo>> searchHits = search.getSearchHits();
  258.         List<EsSourceInfo> esSourceInfos = mappingHighlight(searchHits);
  259.         Page infos = new PageImpl(
  260.                 esSourceInfos,
  261.                 pageRequest,
  262.                 search.getTotalHits());
  263.         Map<String, Object> map = new HashMap<>();
  264.         map.put("page",infos);
  265.         map.put("ag",formatFacet(aggregations));
  266.         return map;
  267.     }
  268.     
  269.     /**
  270.       * 根据条件获取聚类信息 
  271.       * springboot-data 封装的聚类查询速度很慢，这里直接用client操作
  272.       * @author Innocence
  273.       * @date 2021/3/19
  274.       * @param query, indexName]
  275.       * @return java.util.Map<java.lang.String,java.util.List<? extends org.elasticsearch.search.aggregations.bucket.terms.Terms.Bucket>>
  276.       */
  277.     public Map<String, List<? extends Terms.Bucket>> getFacetByQuery(SearchSourceBuilder query, String indexName) throws IOException {
  278.         SearchRequest request = new SearchRequest(indexName);
  279.         SearchSourceBuilder builder = query;
  280.         request.source(builder);
  281.         SearchResponse response = highLevelClient.search(request, RequestOptions.DEFAULT);
  282.         Aggregations aggregations = response.getAggregations();
  283.         return formatFacet(aggregations);
  284.     }
  285.  
  286.     /**
  287.      * 格式化聚类数据
  288.      * @author Innocence
  289.      * @param aggregations
  290.      * @return java.util.Map<java.lang.String,java.util.List<java.util.Map<java.lang.String,java.lang.Object>>>
  291.      */
  292.     private Map<String, List<? extends Terms.Bucket>> formatFacet(Aggregations aggregations){
  293.         if (aggregations == null){
  294.             return null;
  295.         }
  296.         Map<String, List<? extends Terms.Bucket>> map = new HashMap<>();
  297.         List<Aggregation> list = aggregations.asList();
  298.         list.forEach(item->{
  299.             ParsedStringTerms newItem = (ParsedStringTerms) item;
  300.             String name = newItem.getName();
  301.             List<? extends Terms.Bucket> buckets = newItem.getBuckets();
  302.             map.put(name,buckets);
  303.         });
  304.         return map;
  305.     }
  306. }
  • 六、条件构造案例

上面的文档操作中，提到很多个Query条件构造器，其中IndexQuery和UpdateQuery上面的操作工具类里面就有构造方式和使用方法，主要还是关于查询的Query，很多同学可能会一脸蒙蔽，这里放一个我项目中使用的真实案列，具体的细节还要多看文档。

  1. package com.cqvip.innocence.project.controller.front.search;
  2.  
  3. import cn.hutool.core.util.StrUtil;
  4. import com.cqvip.innocence.common.annotation.SensitiveTag;
  5. import com.cqvip.innocence.common.constant.EsIndexConstant;
  6. import com.cqvip.innocence.project.esservice.DocumentService;
  7. import com.cqvip.innocence.project.model.dto.JsonResult;
  8. import com.cqvip.innocence.project.model.dto.SearchModel;
  9. import com.cqvip.innocence.project.model.dto.SearchParams;
  10. import com.cqvip.innocence.project.model.enums.ResourceType;
  11. import com.cqvip.innocence.project.model.enums.SearchFiled;
  12. import io.swagger.annotations.ApiOperation;
  13. import org.elasticsearch.index.query.*;
  14. import org.elasticsearch.search.aggregations.AggregationBuilders;
  15. import org.elasticsearch.search.aggregations.BucketOrder;
  16. import org.elasticsearch.search.aggregations.bucket.terms.Terms;
  17. import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
  18. import org.elasticsearch.search.builder.SearchSourceBuilder;
  19. import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
  20. import org.elasticsearch.search.sort.SortBuilder;
  21. import org.elasticsearch.search.sort.SortBuilders;
  22. import org.elasticsearch.search.sort.SortOrder;
  23. import org.springframework.beans.factory.annotation.Autowired;
  24. import org.springframework.data.domain.PageRequest;
  25. import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
  26. import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
  27. import org.springframework.web.bind.annotation.*;
  28.  
  29. import javax.servlet.http.HttpServletRequest;
  30. import java.io.IOException;
  31. import java.util.*;
  32. import java.util.stream.Collectors;
  33.  
  34. /**
  35.  * @ClassName CommonSearchController
  36.  * @Description 前台通用的检索接口
  37.  * @Author Innocence
  38.  * @Date 2021/3/18 9:26
  39.  * @Version 1.0
  40.  */
  41. @RestController
  42. @RequestMapping("/search/")
  43. public class CommonSearchController {
  44.  
  45.     @Autowired
  46.     private DocumentService documentService;
  47.  
  48.     
  49.     @GetMapping("getArticleFacetsToMedia")
  50.     @ApiOperation("期刊详情页获取文献年期聚类")
  51.     public JsonResult getArticleFacets(String gch) throws IOException {
  52.         BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
  53.         boolQueryBuilder.must(QueryBuilders.matchQuery("workType",ResourceType.ARTICLE.getCode()))
  54.                 .must(QueryBuilders.termQuery("gch",gch));
  55.         TermsAggregationBuilder yearsFacet = AggregationBuilders
  56.                 .terms("years")
  57.                 .field("years")
  58.                 .order(BucketOrder.key(false))
  59.                 .size(150);
  60.         yearsFacet.subAggregation(AggregationBuilders
  61.                 .terms("num")
  62.                 .field("num")
  63.                 .order(BucketOrder.key(true))
  64.                 .size(150));
  65.         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
  66.         searchSourceBuilder.query(boolQueryBuilder).aggregation(yearsFacet);
  67.         Map<String, List<? extends Terms.Bucket>> facetByQuery = documentService.getFacetByQuery(searchSourceBuilder, EsIndexConstant.INDEX_NAME);
  68.         return JsonResult.Get().putRes(facetByQuery);
  69.     }
  70.     
  71.     @SensitiveTag
  72.     @PostMapping("advanceSearch")
  73.     @ApiOperation("所有资源分页检索")
  74.     public JsonResult getAllSourcePage(@RequestBody  SearchParams params,HttpServletRequest request){
  75.         Integer current;
  76.         //设置分页
  77.         if (params.getPageNum() == null){
  78.             current = 0;
  79.         }else {
  80.             current = params.getPageNum()-1;
  81.         }
  82.         if (params.getPageSize() == null){
  83.             params.setPageSize(20);
  84.         }
  85.         PageRequest pageRequest = PageRequest.of(current,params.getPageSize());
  86.         BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
  87.         NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
  88.         //排序
  89.         if (params.getSortMap()!= null){
  90.             nativeSearchQueryBuilder = setSort(params.getSortMap());
  91.         }
  92.         // 聚类
  93.         List<String> list = new ArrayList<>();
  94.         list.add("workType");
  95.         list.add("classTypesArrays");
  96.         list.add("keywordsArrays");
  97.         list.add("writersArrays");
  98.         List<TermsAggregationBuilder> termsAggregationBuilders = addAggregation(list);
  99.         for (TermsAggregationBuilder item:termsAggregationBuilders) {
  100.             nativeSearchQueryBuilder.addAggregation(item);
  101.         }
  102.         setParams(params,boolQueryBuilder,nativeSearchQueryBuilder);
  103.         NativeSearchQuery build = nativeSearchQueryBuilder
  104.                 .withQuery(boolQueryBuilder)
  105.                 .withPageable(pageRequest)
  106.                 .build();
  107.         Map<String, Object> pageList = documentService.getPageList(build, pageRequest);
  108.         return JsonResult.Get().putRes(pageList);
  109.     }
  110.  
  111.     /**
  112.      * 所有资源查询的时候组装条件
  113.      * @author Innocence
  114.      * @date 2021/3/23
  115.      * @param params
  116.      * @param boolQueryBuilder
  117.      * @return void
  118.      */
  119.     @SensitiveTag
  120.     private void setParams(SearchParams params,BoolQueryBuilder boolQueryBuilder,NativeSearchQueryBuilder nativeSearchQueryBuilder){
  121.         List<String> highList = new ArrayList<>();
  122.         List<String> classTypes = params.getClassTypes();
  123.         //学科分类检索
  124.         if (classTypes != null && classTypes.size()>0){
  125.             TermsQueryBuilder termsQueryBuilder = QueryBuilders.termsQuery("classTypesArrays.keyword", classTypes);
  126.             boolQueryBuilder.must(termsQueryBuilder);
  127.         }
  128.         //1、简单检索（可能什么值都不传，那就查询全部数据）
  129.         if (params.getSimpleSearchParams() != null && StrUtil.isNotBlank(params.getSimpleSearchParams().searchKeyword)){
  130.             List<String> fields = getField(params.getSimpleSearchParams().getSearchField());
  131.             fields.forEach(item->highList.add(item));
  132.             DisMaxQueryBuilder queryBuilder = QueryBuilders.disMaxQuery().tieBreaker(0.05f);
  133.             Boolean isExact = params.getSimpleSearchParams().getIsExact();
  134.             fields.forEach(item->{
  135.                 if (item.contains("title") || item.contains("media") || item.contains("book")){
  136.                     MatchQueryBuilder boost = QueryBuilders
  137.                             .matchQuery(item, params.getSimpleSearchParams().searchKeyword).boost(2f);
  138.                     queryBuilder.add(boost);
  139.                 }else{
  140.                     if (isExact != null && isExact == true){
  141.                         QueryBuilder matchPhraseQueryBuilder = QueryBuilders.termQuery(item, params.getSimpleSearchParams().searchKeyword);
  142.                         queryBuilder.add(matchPhraseQueryBuilder);
  143.                     }else {
  144.                         QueryBuilder matchPhraseQueryBuilder = QueryBuilders.matchPhraseQuery(item, params.getSimpleSearchParams().searchKeyword);
  145.                         queryBuilder.add(matchPhraseQueryBuilder);
  146.                     }
  147.                 }
  148.             });
  149.             boolQueryBuilder.must(queryBuilder);
  150.         }
  151.         //2、二次检索
  152.         if (params.getSecondSearchParams() != null && params.getSecondSearchParams().size()>0){
  153.             List<SearchModel> models = params.getSecondSearchParams();
  154.             models.forEach(item->{
  155.                 List<String> fields = getField(item.getSearchField());
  156.                 fields.forEach(h->highList.add(h));
  157.                 DisMaxQueryBuilder queryBuilder = QueryBuilders.disMaxQuery().tieBreaker(0.05f);
  158.                 fields.forEach(e->{
  159.                     if (e.contains("title") || e.contains("media") || e.contains("book")){
  160.                         MatchPhraseQueryBuilder boost = QueryBuilders
  161.                                 .matchPhraseQuery(e, item.getSearchKeyword()).boost(2f);
  162.                         queryBuilder.add(boost);
  163.                     }else{
  164.                         MatchPhraseQueryBuilder matchPhraseQueryBuilder = QueryBuilders
  165.                                 .matchPhraseQuery(e, item.getSearchKeyword());
  166.                         queryBuilder.add(matchPhraseQueryBuilder);
  167.                     }
  168.                 });
  169.                 boolQueryBuilder.must(queryBuilder);
  170.             });
  171.         }
  172.         //3、聚类检索
  173.         if (params.getFacetSearchParams() != null && params.getFacetSearchParams().size() > 0) {
  174.             params.getFacetSearchParams().forEach((item) -> {
  175.                 List<String> fields = getField(item.getSearchField());
  176.                 fields.forEach(h->highList.add(h));
  177.                 DisMaxQueryBuilder queryBuilder = QueryBuilders.disMaxQuery().tieBreaker(0.05f);
  178.                 fields.forEach(e -> {
  179.                     if(e.equals(SearchFiled.WORKTYPE.getValue())){
  180.                         MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery(e, item.getSearchKeyword());
  181.                         queryBuilder.add(matchQueryBuilder);
  182.                     }else {
  183.                         MatchPhraseQueryBuilder matchPhraseQueryBuilder = QueryBuilders.matchPhraseQuery(e, item.getSearchKeyword());
  184.                         queryBuilder.add(matchPhraseQueryBuilder);
  185.                     }
  186.                 });
  187.                 boolQueryBuilder.must(queryBuilder);
  188.             });
  189.         }
  190.         //4、高级检索
  191.         if (params.getAdvanceSearchParams() != null && params.getAdvanceSearchParams().size() > 0) {
  192.             BoolQueryBuilder bool=new BoolQueryBuilder();
  193.             params.getAdvanceSearchParams().forEach((item) -> {
  194.                 List<String>  fields = getField( item.getSearchField());
  195.                 fields.forEach(h->highList.add(h));
  196.                 //精确
  197.                 BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
  198.                 BoolQueryBuilder child=new BoolQueryBuilder();
  199.                 if (item.getIsExact()) {
  200.                     fields.forEach(field-> child.should(QueryBuilders.termQuery(field,item.getSearchKeyword())));
  201.                     queryBuilder.must(child);
  202.                 }else {
  203.                     MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery(
  204.                             item.getSearchKeyword(), fields.toArray(new String[fields.size()]));
  205.                     queryBuilder.should(multiMatchQueryBuilder);
  206.                 }
  207.  
  208.                 if (StrUtil.equals("AND", item.getLogicOperator().trim())) {
  209.                     bool.must(queryBuilder);
  210.                 } else if (StrUtil.equals("OR", item.getLogicOperator().trim())) {
  211.                     bool.should(queryBuilder);
  212.                 } else if (StrUtil.equals("NOT", item.getLogicOperator().trim())) {
  213.                     bool.mustNot(queryBuilder);
  214.                 }
  215.             });
  216.             boolQueryBuilder.must(bool);
  217.         }
  218.         List<String> highFields = filterHighFields(highList);
  219.         nativeSearchQueryBuilder.withHighlightBuilder(setHighlight(highFields));
  220.     }
  221.  
  222.     /**
  223.      * 根据list设置高亮字段
  224.      * @author Innocence
  225.      * @date 2021/3/23
  226.      * @param list
  227.      * @return org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder
  228.      */
  229.     private HighlightBuilder setHighlight(List<String> list){
  230.         List<String> newList = new ArrayList<>();
  231.         for (int i = 0; i < list.size(); i++) {
  232.             if (list.get(i).indexOf(",") != -1){
  233.                 String[] split = list.get(i).split(",");
  234.                 for (int j = 0; j < split.length; j++) {
  235.                     newList.add(split[j]);
  236.                 }
  237.             }
  238.             newList.add(list.get(i));
  239.         }
  240.         String[] strings = newList.toArray(new String[newList.size()]);
  241.         HighlightBuilder highlightBuilder = documentService.getHighlightBuilder(strings);
  242.         return highlightBuilder;
  243.     }
  244.  
  245.     /**
  246.      * 根据检索对象和缩略词获取字段
  247.      * @param filed   检索字段
  248.      * @return {@link String} 形如  title,title_c
  249.      * @author 01
  250.      * @date 2021/1/19 18:40
  251.      */
  252.     private List<String> getField( SearchFiled filed) {
  253.         List<String> fields = new ArrayList<>();
  254.         //任意字段
  255.         if (StrUtil.equals(filed.getValue(), SearchFiled.ALL.getValue())) {
  256.             SearchFiled[] values = SearchFiled.values();
  257.             for (SearchFiled value : values) {
  258.                 if (StrUtil.equals(value.getValue(), SearchFiled.ALL.getValue())
  259.                         || StrUtil.equals(value.getValue(), SearchFiled.GCH.getValue())
  260.                         || StrUtil.equals(value.getValue(), SearchFiled.PUBLISHER.getValue())) {
  261.                     continue;
  262.                 }
  263.                 fields.add(value.getValue());
  264.             }
  265.             //标题
  266.         }else if (StrUtil.equals(filed.getValue(),SearchFiled.TITLE.getValue())){
  267.             String titleValue = SearchFiled.TITLE.getValue();
  268.             for (String value : titleValue.split(",")) {
  269.                 fields.add(value);
  270.             }
  271.         } else {
  272.             fields.add(filed.getValue());//单独字段
  273.         }
  274.         List<String> strings = new ArrayList<>();
  275.         fields.forEach(item ->{
  276.             if (item.indexOf(",") !=-1){
  277.                 String[] split = item.split(",");
  278.                 for (int i = 0; i < split.length; i++) {
  279.                     strings.add(split[i]);
  280.                 }
  281.             }else {
  282.                 strings.add(item);
  283.             }
  284.         });
  285.         return strings;
  286.     }
  287.  
  288.     /**
  289.      * 组装排序字段
  290.      * @author Innocence
  291.      * @date 2021/3/18
  292.      * @param map
  293.      * @return java.util.List<org.elasticsearch.search.sort.SortBuilder>
  294.      */
  295.     private NativeSearchQueryBuilder setSort(Map<String, SortOrder> map){
  296.         NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
  297.         for(Map.Entry<String, SortOrder> entry : map.entrySet()){
  298.             SortBuilder order;
  299.             if (entry.getKey().startsWith("_")){
  300.                 if (entry.getValue().equals(SortOrder.ASC)){
  301.                     order = SortBuilders.fieldSort(entry.getKey()).order(SortOrder.ASC);
  302.                 }else {
  303.                     order = SortBuilders.fieldSort(entry.getKey()).order(SortOrder.DESC);
  304.                 }
  305.             }else {
  306.                 if (entry.getValue().equals(SortOrder.ASC)){
  307.                     order = SortBuilders.fieldSort(entry.getKey()+".keyword").order(SortOrder.ASC);
  308.                 }else {
  309.                     order = SortBuilders.fieldSort(entry.getKey()+".keyword").order(SortOrder.DESC);
  310.                 }
  311.             }
  312.             nativeSearchQueryBuilder.withSort(order);
  313.         }
  314.         return nativeSearchQueryBuilder;
  315.     }
  316.  
  317.     /**
  318.      * 组装聚类的字段
  319.      * @author Innocence
  320.      * @date 2021/3/18
  321.      * @param fields 需要聚类的字段
  322.      * @return java.util.List<org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder>
  323.      */
  324.     private List<TermsAggregationBuilder> addAggregation(List<String> fields){
  325.         List<TermsAggregationBuilder> builders = new ArrayList<>();
  326.         fields.forEach(item->{
  327.             TermsAggregationBuilder size;
  328.             if (item.equals("workType")){
  329.                 size = AggregationBuilders.terms(item).field(item+".keyword").size(150);
  330.             }else {
  331.                 size = AggregationBuilders.terms(item).field(item).size(150);
  332.             }
  333.             builders.add(size);
  334.         });
  335.         return builders;
  336.     }
  337.     
  338.  
  339.     /**
  340.      * 高亮字段不能为数组字段，这里要处理一下
  341.      * @author Innocence
  342.      * @date 2021/3/24
  343.      * @return void
  344.      */
  345.     private List<String> filterHighFields(List<String> fields){
  346.         List<String> myList = fields.stream().distinct().collect(Collectors.toList());
  347.         List<String> strings = new ArrayList<>();
  348.         for (int i = 0; i < myList.size(); i++) {
  349.             if (myList.get(i).equals(SearchFiled.CLASS_TYPES_ARRAYS.getValue())){
  350.                 strings.add(SearchFiled.CLASS_TYPES.getValue());
  351.             }else if(myList.get(i).equals(SearchFiled.KEYWORDS_ARRAYS.getValue())){
  352.                 strings.add(SearchFiled.KEYWORD.getValue());
  353.             }else if (myList.get(i).equals(SearchFiled.WRITERS_ARRAYS.getValue())){
  354.                 strings.add(SearchFiled.WRITER.getValue());
  355.             }else if(myList.get(i).equals(SearchFiled.COLLECT_DATABASE_ARRAYS.getValue())) {
  356.                 strings.add(SearchFiled.COLLECT_DATABASE.getValue());
  357.             }else if(myList.get(i).equals("workType")){
  358.                 continue;
  359.             }else {
  360.                 strings.add(myList.get(i));
  361.             }
  362.         }
  363.         return strings.stream().distinct().collect(Collectors.toList());
  364.     }
  365.  
  366. }
  367.

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

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

  

闽ICP备14008679号