ElasticSearch排序/分页查询

￡神魔★判官ぃ 2022-04-02 19:46 421阅读 0赞

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;
        }
    }