SpringBoot 整合 Elasticsearch深度分页查询

es 查询共有4种查询类型

QUERY_AND_FETCH:

　　主节点将查询请求分发到所有的分片中，各个分片按照自己的查询规则即词频文档频率进行打分排序，然后将结果返回给主节点，主节点对所有数据进行汇总排序然后再返回给客户端，此种方式只需要和es交互一次。

这种查询方式存在数据量和排序问题，主节点会汇总所有分片返回的数据这样数据量会比较大，二是各个分片上的规则可能不一致。

QUERY_THEN_FETCH:

主节点将请求分发给所有分片，各个分片打分排序后将数据的id和分值返回给主节点，主节点收到后进行汇总排序再根据排序后的id到对应的节点读取对应的数据再返回给客户端，此种方式需要和es交互两次。

这种方式解决了数据量问题但是排序问题依然存在而且是es的默认查询方式

DEF_QUERY_AND_FETCH 和 DFS_QUERY_THEN_FETCH:

　　将各个分片的规则统一起来进行打分。解决了排序问题但是DFS_QUERY_AND_FETCH仍然存在数据量问题，DFS_QUERY_THEN_FETCH两种噢乖你问题都解决但是效率是最差的。

Maven依赖：

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
　　　 <version>2.0.5.RELEASE</version>　
    </dependency>

yml配置：

spring:
    data:
        elasticsearch:
             cluster-name: elasticsearch
             cluster-nodes: 127.0.0.1:9300

测试代码：

 /**
  * @author 宫新程
  * @since 2018/10/24 12:29
  */
 @RunWith(SpringRunner.class)
 @SpringBootTest
 @Slf4j
 public class GoodsItemLaunchEsTest {

   // 查询条件
   private static final String ES_SEARCH_ITEM_NAME = "itemName";
   private static final String ES_SEARCH_ITEM_MODEL = "itemModel";
   private static final String ES_SEARCH_PRODUCT_CODE = "productCode";
   private static final String ES_SEARCH_OPER_FLAG = "oper_flag";

   @Resource private ElasticsearchTemplate elasticsearchTemplate;
   @Resource private EsManager esManager;

   /** ES创建基础表 */
   @Test
   public void createIndex() {
     elasticsearchTemplate.createIndex(EsGoodsItemLaunchDto.class);
     elasticsearchTemplate.putMapping(EsGoodsItemLaunchDto.class);
   }

   /** ES删除表 */
   @Test
   public void deleteIndex() {
     this.elasticsearchTemplate.deleteIndex(EsGoodsItemLaunchDto.class);
   }

   /** 插入测试数据 */
   @Test
   public void insertData() {

     List<IndexQuery> queryList = new ArrayList<>();

     for (int i = 0; i < 10000; i++) {
       EsGoodsItemLaunchDto dto = new EsGoodsItemLaunchDto();
       dto.setId(i);
       dto.setItemId(i);
       dto.setItemSkuId(i);
       dto.setItemName(i % 2 == 0 ? "洗衣机" + i : "空调" + i);
       dto.setCustomerSellerCode("CustomerSellerCode" + i);
       dto.setCustomerName("CustomerName" + i);
       dto.setMemberSellerCode("MemberSellerCode" + i);
       dto.setMemberName("MemberName" + i);
       dto.setProductCode("ProductCode" + i);
       dto.setItemModel("ItemModel" + i);
       dto.setProductGroupName("ProductGroupName" + i);
       dto.setProductGroupCode("ProductGroupCode" + i);
       dto.setBrandId(i * 2);
       dto.setBrandName("BrandName" + i);
       dto.setGmCode(((int) Math.random() * 10000) + "");
       dto.setUpdateTime(new Date());
       dto.setMemberId(i * 5);
       dto.setCustomerId(i * 6);

       IndexQuery indexQuery =
           new IndexQueryBuilder()
               .withId(String.valueOf(dto.getId()))
               .withObject(dto)
               .withIndexName(esManager.index4r(EsGoodsItemLaunchDto.class))
               .build();

       queryList.add(indexQuery);

       if (queryList.size() == 1000) {
         this.elasticsearchTemplate.bulkIndex(queryList);
         queryList.clear();
       }
     }

     // 必须加if判断否则报异常：
     // org.elasticsearch.action.ActionRequestValidationException:
     // Validation Failed: 1:no requests added;
     if (queryList.size() > 0) {
       // 保存剩余数据 (没被1000整除)
       elasticsearchTemplate.bulkIndex(queryList);
     }
   }

   @Test
   public void search() {
     int pageNum = 2;
     int pageSize = 5;

     BoolQueryBuilder filter = QueryBuilders.boolQuery();
     // 注意一定要小写处理 toLowerCase()
     String codeOrName = "ProductCode100".toLowerCase();
     BoolQueryBuilder boolQueryLike = QueryBuilders.boolQuery();
     // 分词查询 商品名称
     MultiMatchQueryBuilder queryBuilder =
         QueryBuilders.multiMatchQuery(codeOrName, ES_SEARCH_ITEM_NAME);
     // 商品型号
     QueryBuilder itemModel =
         QueryBuilders.wildcardQuery(ES_SEARCH_ITEM_MODEL, "*" + codeOrName + "*");
     // 产品编码
     QueryBuilder productCode =
         QueryBuilders.wildcardQuery(ES_SEARCH_PRODUCT_CODE, "*" + codeOrName + "*");
     boolQueryLike.should(queryBuilder);
     boolQueryLike.should(itemModel);
     boolQueryLike.should(productCode);
     filter.must(boolQueryLike);

     // 判断ES表的 oper_flag 不等于 D
     filter.mustNot(QueryBuilders.termQuery(ES_SEARCH_OPER_FLAG, "D"));

     SearchQuery searchQuery = new NativeSearchQuery(filter);
     searchQuery.addIndices(esManager.index4r(EsGoodsItemLaunchDto.class));
     Pageable pageable = PageRequest.of(pageNum - 1, pageSize);
     searchQuery.setPageable(pageable);

     // 深度查询分页
     Page<EsGoodsItemLaunchDto> result =
         this.elasticsearchTemplate.startScroll(5000, searchQuery, EsGoodsItemLaunchDto.class);

     for (int i = 0; i < pageNum - 1; i++) {
       elasticsearchTemplate.continueScroll(
           ((ScrolledPage) result).getScrollId(), 5000, EsGoodsItemLaunchDto.class);
     }

     log.info("=====================================");
     result
         .getContent()
         .forEach(
             (dto) -> {
               log.info("ItemName：{}", dto.getItemName());
             });
     log.info("总记录数：{}", result.getTotalElements());
     log.info("当前页码数：{}", pageNum);
     log.info("每页显示条数：{}", pageSize);
     log.info("=====================================");
   }
 }
 /* 输出结果：
 <============================>
 <ItemName：空调1001>
 <ItemName：洗衣机1004>
 <ItemName：洗衣机1006>
 <ItemName：空调1007>
 <ItemName：洗衣机1008>
 <总记录数：11>
 <当前页码数：2>
 <每页显示条数：5>
 <============================>
 */