ElasticSearch排序/分页查询

package com.czxy.service;

import com.czxy.dao.SkuRepository;
import com.czxy.vo.*;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders; 
import org.elasticsearch.search.sort.SortBuilders;
import org.elasticsearch.search.sort.SortOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

/**
 * @author  
 * @create 2018-12-25 18:32
 * @desc 条件查询
 */
@Service
@Transactional
public class SkuSearchService {
	/**
    *@author  
    *@create  2018/12/26
    *@desc dao层  用来执行查询
    */
    @Autowired
    private SkuRepository skuRepository;
    
    /**
     *@author 
     *@create 2018/12/26 16:12
     *@Param [skuSearchRequest]
     *@return org.springframework.http.ResponseEntity<java.lang.Object>
     *@desc  条件查询  商品
     */
    public SearchResult search(SkuSearchRequest req) {
        //如果三级分类为空

        if(req.getCatid()==null){
            SearchResult br = new SearchResult();
            br.setErrno(1);
            br.setErrmsg("没有数据");
            return  br;
        }
        //1 创建查询构建器s
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        //2. 多条件查询  使用boolQuery    可以new  但是可以使用静态 建议使用静态
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        // 3.  cat3id  分类    不分词匹配（整数）
        boolQuery.must(QueryBuilders.termQuery("cat3_id",req.getCatid()));
        // 4.品牌    不分词匹配（整数）
        if(req.getBrand_id()!=null&&!"".equals(req.getBrand_id())) {
            boolQuery.must(QueryBuilders.termQuery("brand_id", req.getBrand_id()));
        }
        // 5.规格
        HashMap<String,String> map=null;
        //先判断规格是否为null
        if(req.getSpec_list()!=null&&!"".equals(req.getSpec_list())){
            //不为null  进行排序
            map=new HashMap<String,String>();
            //进行切割  存入map  机身颜色=金色，内存=4GB，机身颜色=
            String[] specList = req.getSpec_list().split(",");

            for (String s : specList) {
                //进行二次分割   机身颜色=金色
                String[] split = s.split("=");
                //是否 第二个参数为空   机身颜色=
                if(split.length==1){
                    //删除相对已有的
                    map.remove(split[0]);
                }else{
                    //存入map key:机身颜色  value:金色
                    map.put(split[0],split[1]);
                }
            }
            if(map!=null){
                //第一种遍历方式
//                Set<Map.Entry<String, String>> entries = map.entrySet();
//                for (Map.Entry<String, String> entry : entries) {
//                    entry.getKey()
//                    entry.getValue()
//                }

                //遍历map
                Set<String> set = map.keySet();
                for (String key : set) {
                    //value
                    String value=map.get(key);
                    //组装key
                    //在es中   specs.机身颜色.keyword  =红色
                    key="specs."+key+".keyword";
                    //搜索 es中的map
                    boolQuery.must(QueryBuilders.termQuery(key,value));
                }
            }
        }
        // 6 最低价格
        if(req.getMin_price()!=null){
            //支持单个查询   大于等于 最低价格
            boolQuery.must(QueryBuilders.rangeQuery("price").gte(req.getMin_price()));
        }
        // 7  最高价格
        if(req.getMax_price()!=null){
            //支持单个查询   小于等于最高价格
            boolQuery.must(QueryBuilders.rangeQuery("price").lte(req.getMax_price()));
        }

        // 8   排序字段
        if(req.getSort_by()!=null) {
            //销量排序  默认降序
            if (req.getSort_by().equals("xl")) {
                queryBuilder.withSort(SortBuilders.fieldSort("seller_count").order(SortOrder.DESC));
            }
            //价格排序
            else if (req.getSort_by().equals("jg")) {
                 //降序情况
                if (req.getSort_way().equalsIgnoreCase("desc")) {
                    queryBuilder.withSort(SortBuilders.fieldSort("price").order(SortOrder.DESC));
                } else {
                //升序情况
                    queryBuilder.withSort(SortBuilders.fieldSort("price").order(SortOrder.ASC));
                }
            }
            //评论  默认降序
            else if (req.getSort_by().equals("pl")) {
                queryBuilder.withSort(SortBuilders.fieldSort("comment_count").order(SortOrder.DESC));
            }
            //上架时间  默认降序
            else if (req.getSort_by().equals("sj")) {
                queryBuilder.withSort(SortBuilders.fieldSort("on_sale_time").order(SortOrder.DESC));
            }
        }
        // 9 分页     为什么页数要减一，因为elasticsearch 页数从0开始
        queryBuilder.withPageable(PageRequest.of((req.getPage()-1),req.getLimit()));
        // 10 queryBuilder 管理  boolQuery
        queryBuilder.withQuery(boolQuery);
        //执行查询
        Page<SearchSku> page = this.skuRepository.search(queryBuilder.build());
        long count = page.getTotalElements();
        //准备返回data
        ArrayList<ReturnSku> list = new ArrayList<>();
        for (SearchSku s : page) {
            ReturnSku sku = new ReturnSku();
            sku.setId(s.getId());
            sku.setGoods_name(s.getSku_name());
            sku.setPrice(s.getPrice());
            sku.setMidlogo(s.getLogo());
            sku.setComment_count(s.getComment_count());
            list.add(sku);
        }
        //准备返回
        SearchResult result = new SearchResult(0,"成功",list,(int)count,req.getCatid());
        return result;
    }
}