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>
<============================>
*/