搜索模块 elasticsSearch

搜索模块 elasticsSearch

自己所需，没头没尾，见谅

1、创建库的数据结构

//创建数据库根据java类
elasticsearchRestTemplate.createIndex(Goods.class);
//创建库的数据结构
elasticsearchRestTemplate.putMapping(Goods.class);

2、添加方法

GoodsElasicsearchRepository这个类需要继承ElasticsearchRepository<Goods,Long>参数1、生成库类型，参数2、id类型
goodsElasticsearchRepository.save(goods);

3、删除方法

goodsElasticsearchRepository.deleteById(skuId);

4、跟新热度值(防止频繁操作elacticsSearch库导致性能降低，我们将热度值放到redis中，统一在存放elastics中)

 public void hotScore(Long skuId) {

        Integer hotScoreRedis = (Integer)redisTemplate.opsForValue().get("hotScore:"+skuId);
         if(null!=hotScoreRedis){
            hotScoreRedis++;
           // redisTemplate.opsForValue().set("hotScore:"+skuId,hotScoreRedis);
           //可以解决缓存乱序问题
            redisTemplate.opsForValue().increment("hotScore:"+skuId,1);
            if(hotScoreRedis%10==0){
                Goods goods = goodsElasticsearchRepository.findById(skuId).get();
                goods.setHotScore(hotScoreRedis.longValue());
                goodsElasticsearchRepository.save(goods);
            }
        }else{
            redisTemplate.opsForValue().set("hotScore:"+skuId,1);
        }
    }

5、查询

当你查询的时候肯定是根据条件查询，查询有封装请求数据和解析返回结果两个板块

//需要封装请求数据
SearchRequest searchRequest = getSearchRequest(searchParam);

//创建请求
SearchRequest searchRequest = new SearchRequest();
//创建请求连接库
searchRequest.indices("goods");
//创建请求连接表
searchRequest.types("info");
//创建一个多条件查询
BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();
//创建一个term查询，并且添加到bool里，term属于精确匹配
if(!StringUtils.isEmpty(trademark)){
TermQueryBuilder termQueryBuilder = new TermQueryBuilder("tmId",trademark.split(":")[0]);
            boolQueryBuilder.filter(termQueryBuilder);
        }
//创建一个match查询，属于模糊匹配，添加到bool里，也就说多条件查询bool有两个条件
 if(!StringUtils.isEmpty(keyword)){
	MatchQueryBuilder matchQueryBuilder = new MatchQueryBuilder("title", keyword);
    boolQueryBuilder.must(matchQueryBuilder);
        }

//nested查询比较特殊，因为他在bool查询之下又需要再次查询，
//创建一个多列查询
BoolQueryBuilder boolQueryBuilderNested = new BoolQueryBuilder();
//创建一个term查询
TermQueryBuilder termQueryBuilder = new TermQueryBuilder("attrs.attrId", attrId);
//创建一个模糊查询
MatchQueryBuilder matchQueryBuilder = new MatchQueryBuilder("attrs.attrValue", attrValueName);
      boolQueryBuilderNested.filter(termQueryBuilder);
      boolQueryBuilderNested.must(matchQueryBuilder);
NestedQueryBuilder nestedQueryBuilder = new NestedQueryBuilder("attrs", boolQueryBuilderNested, ScoreMode.None);
//如果有参数那么就过滤,最后将nestedBool查询添加到外层bool查询
boolQueryBuilder.filter(nestedQueryBuilder);

----//最终
//向主搜索请求中可以添加搜索内容的特征参数
//创建搜索内容参数设置对象:SearchSourceBuilder
searchSourceBuilder.query(boolQueryBuilder);

创建聚合查询

//商标聚合
TermsAggregationBuilder termsAggregationBuilder = AggregationBuilders.terms("tmIdAgg").field("tmId")
//tmIdAgg下的子聚合查询
.subAggregation(AggregationBuilders.terms("tmNameAgg").field("tmName"))            .subAggregation(AggregationBuilders.terms("tmLogoUrlAgg").field("tmLogoUrl"));
//搜索请求
searchSourceBuilder.aggregation(termsAggregationBuilder);
---------------------------------------------------------------------------------
            //属性聚合
NestedAggregationBuilder nestedAggregationBuilder = AggregationBuilders.nested("attrsAgg", "attrs")            .subAggregation(AggregationBuilders.terms("attrIdAgg").field("attrs.attrId")           .subAggregation(AggregationBuilders.terms("attrNameAgg").field("attrs.attrName"))     .subAggregation(AggregationBuilders.terms("attrValueAgg").field("attrs.attrValue")));
searchSourceBuilder.aggregation(nestedAggregationBuilder);

//页面size
searchSourceBuilder.size(20);
searchSourceBuilder.from(0);
//设置高亮
HighlightBuilder highlightBuilder = new HighlightBuilder();
highlightBuilder.preTags("<span style='color:red;font-weight:bolder'>");
highlightBuilder.field("title");
highlightBuilder.postTags("</span>");
searchSourceBuilder.highlighter(highlightBuilder);

//排序
        if(!StringUtils.isEmpty(order)){
            String key = order.split(":")[0];
            String sort = order.split(":")[1];
            String sortName = "hotScore";
            if(key.equals("2")){
                sortName="price";
            }
searchSourceBuilder.sort(sortName, sort.equals("asc")?SortOrder.ASC:SortOrder.DESC);
        }
 //将SearchSourceBuilder对象添加到搜索请求中:
searchRequest.source(searchSourceBuilder);

返回数据模板字段

public class SearchResponseVo implements Serializable {

    //品牌 此时vo对象中的id字段保留（不用写） name就是“品牌” value: [{id:100,name:华为,logo:xxx},{id:101,name:小米,log:yyy}]
    private List<SearchResponseTmVo> trademarkList;
    //所有商品的顶头显示的筛选属性
    private List<SearchResponseAttrVo> attrsList = new ArrayList<>();

    //检索出来的商品信息
    private List<Goods> goodsList = new ArrayList<>();

    private Long total;//总记录数
    private Integer pageSize;//每页显示的内容
    private Integer pageNo;//当前页面
    private Long totalPages;
}

6、解析返回结果

SearchResponseVo searchResponseVo = new SearchResponseVo();//返回数据模板
//由于返回结果是层级显示
//返回结果层级hits
SearchHits hits = searchResponse.getHits();
//第二层hits
SearchHit[] hitsResult = hits.getHits();
//如果返回结果不是null
if (null != hitsResult && hitsResult.length > 0) {
 //封装数据集合
 List<Goods> goods1 = new ArrayList<>();   
    //遍历数据
      for (SearchHit searchHit : hitsResult) {
          //返回结果数据遍历会的到的对象，并且解析成json字符串
          String json = searchHit.getSourceAsString();
          //将json字符串转换成对象
          Goods goods = JSON.parseObject(json, Goods.class);
          //高亮字段
Map<String, HighlightField> highlightFields = searchHit.getHighlightFields();
           if(null!=highlightFields&&highlightFields.size()>0){
               //获取title为高亮字段
               HighlightField title = highlightFields.get("title");
               //获取title的字段
               Text text = title.getFragments()[0];
               //将已经被高亮处理的title字段转成string赋值对象
               String em = text.string();
               goods.setTitle(em);
           }
          //数据集合封装
          goods1.add(goods);
  }
    //将获得数据集合封装到返回模板集合里，商品
    searchResponseVo.setGoodsList(goods1);
     //取出商标聚合,tmIdAgg是你在请求时设置的字段
     ParsedLongTerms tmIdAgg = searchResponse.getAggregations().get("tmIdAgg");
     //获取子聚合
     List<? extends Terms.Bucket> tmIdAggBuckets = tmIdAgg.getBuckets();
    //将子聚合遍历
    for (Terms.Bucket tmIdAggBucket : tmIdAggBuckets) {
        //子聚合值模板
         SearchResponseTmVo searchResponseTmVo = new SearchResponseTmVo();
         //取出id
         long tmId = tmIdAggBucket.getKeyAsNumber().longValue();
        //取出name
ParsedStringTerms tmNameAgg = tmIdAggBucket.getAggregations().get("tmNameAgg");
List<? extends Terms.Bucket> tmNameAggBuckets = tmNameAgg.getBuckets();
        //因为聚合分组数据的值得是一样的
         String tmName = tmNameAggBuckets.get(0).getKeyAsString();
		//取出url
arsedStringTerms tmLogoUrlAgg = tmIdAggBucket.getAggregations().get("tmLogoUrlAgg");
List<? extends Terms.Bucket> tmLogoUrlAggBuckets = tmLogoUrlAgg.getBuckets();
                String tmLogoUrl = tmLogoUrlAggBuckets.get(0).getKeyAsString();
                searchResponseTmVo.setTmId(tmId);
                searchResponseTmVo.setTmName(tmName);
                searchResponseTmVo.setTmLogoUrl(tmLogoUrl);
                searchResponseTmVos.add(searchResponseTmVo);
            }
    //品牌集合,赋值给最大的模板
    searchResponseVo.setTrademarkList(searchResponseTmVos);
     //属性聚合
            ParsedNested attrsAgg = searchResponse.getAggregations().get("attrsAgg");

            ParsedLongTerms attrIdAgg = attrsAgg.getAggregations().get("attrIdAgg");
List<SearchResponseAttrVo> attrList = attrIdAgg.getBuckets().stream().map(attrIdBucket -> {SearchResponseAttrVo searchResponseAttrVo = new SearchResponseAttrVo();
                //id
                long attrId = attrIdBucket.getKeyAsNumber().longValue();
                //name
                ParsedStringTerms attrNameAgg = attrIdBucket.getAggregations().get("attrNameAgg");
                String attrName = attrNameAgg.getBuckets().get(0).getKeyAsString();
                //valueList
ParsedStringTerms attrValueAgg = attrIdBucket.getAggregations().get("attrValueAgg");
List<String> attrValueList = attrValueAgg.getBuckets().stream().map(attrValueBucket -> {String attrValue = attrValueBucket.getKeyAsString();returnattrValue;}).collect(Collectors.toList());
                searchResponseAttrVo.setAttrId(attrId);
                searchResponseAttrVo.setAttrName(attrName);
                searchResponseAttrVo.setAttrValueList(attrValueList);
                return searchResponseAttrVo;
            }).collect(Collectors.toList());
    		//将属性集合赋值给最大的模板
            searchResponseVo.setAttrsList(attrList);
}
//将最大的模板返回
 return searchResponseVo;
}