|
|
|
package com.yoho.search.service.servicenew.impl;
|
|
|
|
|
|
|
|
import java.util.ArrayList;
|
|
|
|
import java.util.Arrays;
|
|
|
|
import java.util.Collections;
|
|
|
|
import java.util.HashMap;
|
|
|
|
import java.util.Iterator;
|
|
|
|
import java.util.List;
|
|
|
|
import java.util.Map;
|
|
|
|
|
|
|
|
import org.apache.commons.lang.StringUtils;
|
|
|
|
import org.elasticsearch.index.query.BoolQueryBuilder;
|
|
|
|
import org.elasticsearch.index.query.QueryBuilder;
|
|
|
|
import org.elasticsearch.index.query.QueryBuilders;
|
|
|
|
import org.elasticsearch.index.query.functionscore.FunctionScoreQueryBuilder;
|
|
|
|
import org.elasticsearch.index.query.functionscore.ScoreFunctionBuilders;
|
|
|
|
import org.elasticsearch.search.SearchHit;
|
|
|
|
import org.elasticsearch.search.SearchHits;
|
|
|
|
import org.elasticsearch.search.aggregations.AbstractAggregationBuilder;
|
|
|
|
import org.elasticsearch.search.aggregations.Aggregation;
|
|
|
|
import org.elasticsearch.search.aggregations.AggregationBuilders;
|
|
|
|
import org.elasticsearch.search.aggregations.bucket.MultiBucketsAggregation;
|
|
|
|
import org.elasticsearch.search.aggregations.bucket.MultiBucketsAggregation.Bucket;
|
|
|
|
import org.elasticsearch.search.aggregations.bucket.terms.TermsBuilder;
|
|
|
|
import org.elasticsearch.search.aggregations.metrics.tophits.TopHits;
|
|
|
|
import org.elasticsearch.search.sort.SortBuilder;
|
|
|
|
import org.elasticsearch.search.sort.SortBuilders;
|
|
|
|
import org.elasticsearch.search.sort.SortOrder;
|
|
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
|
|
import org.springframework.stereotype.Service;
|
|
|
|
|
|
|
|
import com.alibaba.fastjson.JSONArray;
|
|
|
|
import com.alibaba.fastjson.JSONObject;
|
|
|
|
import com.yoho.search.base.utils.ISearchConstants;
|
|
|
|
import com.yoho.search.core.es.model.SearchParam;
|
|
|
|
import com.yoho.search.core.es.model.SearchResult;
|
|
|
|
import com.yoho.search.service.cache.CacheEnum;
|
|
|
|
import com.yoho.search.service.personalized.PersonalVectorFeatureSearch;
|
|
|
|
import com.yoho.search.service.service.SearchCacheService;
|
|
|
|
import com.yoho.search.service.service.SearchCommonService;
|
|
|
|
import com.yoho.search.service.service.helper.AggProductListHelper;
|
|
|
|
import com.yoho.search.service.service.helper.FunctionScoreSearchHelper;
|
|
|
|
import com.yoho.search.service.service.helper.SearchCommonHelper;
|
|
|
|
import com.yoho.search.service.service.helper.SearchServiceHelper;
|
|
|
|
import com.yoho.search.service.service.helper.SearchSortHelper;
|
|
|
|
import com.yoho.search.service.servicenew.IGoodProductsService;
|
|
|
|
import com.yoho.search.service.utils.SearchRequestParams;
|
|
|
|
import com.yoho.search.service.vo.SearchApiResult;
|
|
|
|
|
|
|
|
@Service
|
|
|
|
public class GoodProductListService implements IGoodProductsService {
|
|
|
|
|
|
|
|
@Autowired
|
|
|
|
private SearchCommonService searchCommonService;
|
|
|
|
@Autowired
|
|
|
|
private SearchServiceHelper searchServiceHelper;
|
|
|
|
@Autowired
|
|
|
|
private FunctionScoreSearchHelper functionScoreSearchHelper;
|
|
|
|
@Autowired
|
|
|
|
private SearchCacheService searchCacheService;
|
|
|
|
@Autowired
|
|
|
|
private AggProductListHelper aggProductListHelper;
|
|
|
|
@Autowired
|
|
|
|
private SearchSortHelper searchSortHelper;
|
|
|
|
@Autowired
|
|
|
|
private SearchCommonHelper searchCommonHelper;
|
|
|
|
@Autowired
|
|
|
|
private PersonalVectorFeatureSearch personalVectorFeatureSearch;
|
|
|
|
|
|
|
|
private final int maxSmallSortCount = 20;
|
|
|
|
private final int maxProductSknCountPerSort = 5;
|
|
|
|
private final int maxCountPerGroup = 10;
|
|
|
|
private final float firstSknScore = 300;
|
|
|
|
private final float recommendedSknMaxScore = 200;
|
|
|
|
|
|
|
|
@Override
|
|
|
|
public SearchApiResult goodProductList(Map<String, String> paramMap) {
|
|
|
|
// 1、检测分页参数
|
|
|
|
int pageSize = StringUtils.isBlank(paramMap.get("viewNum")) ? 30 : Integer.parseInt(paramMap.get("viewNum"));
|
|
|
|
int page = StringUtils.isBlank(paramMap.get("page")) ? 1 : Integer.parseInt(paramMap.get("page"));
|
|
|
|
if (page < 1 || pageSize < 0) {
|
|
|
|
return new SearchApiResult().setCode(400).setMessage("分页参数不合法");
|
|
|
|
}
|
|
|
|
// 2、先获取用户浏览的SKN对应的品类列表
|
|
|
|
List<Integer> smallSortIds = this.getProductSknSmallSortIds(paramMap, maxSmallSortCount);
|
|
|
|
// 3、再每个品类下获取5个SKN
|
|
|
|
List<String> recommondSkns = this.getRecommondedSkns(smallSortIds, maxProductSknCountPerSort, paramMap);
|
|
|
|
|
|
|
|
// 4、构造搜索参数
|
|
|
|
SearchParam searchParam = new SearchParam();
|
|
|
|
searchParam.setFiter(this.getDefaultBoolQueryBuilder());
|
|
|
|
searchParam.setQuery(this.builderGoodProductQueryBuilder(paramMap, recommondSkns));
|
|
|
|
searchParam.setAggregationBuilders(null);
|
|
|
|
searchParam.setPage(page);
|
|
|
|
searchParam.setOffset((page - 1) * pageSize);
|
|
|
|
searchParam.setSize(pageSize);
|
|
|
|
List<SortBuilder> sortBuilders = new ArrayList<SortBuilder>();
|
|
|
|
sortBuilders.add(SortBuilders.fieldSort("_score").order(SortOrder.DESC));
|
|
|
|
sortBuilders.add(SortBuilders.fieldSort("salesNum").order(SortOrder.DESC));
|
|
|
|
sortBuilders.add(SortBuilders.fieldSort("firstShelveTime").order(SortOrder.DESC));
|
|
|
|
sortBuilders.add(SortBuilders.fieldSort("id").order(SortOrder.DESC));
|
|
|
|
searchParam.setSortBuilders(sortBuilders);
|
|
|
|
|
|
|
|
// 5）从缓存中获取数据
|
|
|
|
final String indexName = ISearchConstants.INDEX_NAME_PRODUCT_INDEX;
|
|
|
|
CacheEnum cacheEnum = CacheEnum.EHCACHE;
|
|
|
|
JSONObject cacheObject = searchCacheService.getJSONObjectFromCache(cacheEnum, indexName, searchParam);
|
|
|
|
if (cacheObject != null) {
|
|
|
|
return new SearchApiResult().setData(cacheObject);
|
|
|
|
}
|
|
|
|
// 6)查询ES
|
|
|
|
SearchResult searchResult = searchCommonService.doSearch(indexName, searchParam);
|
|
|
|
if (searchResult == null) {
|
|
|
|
return new SearchApiResult().setCode(500).setMessage("execption");
|
|
|
|
}
|
|
|
|
// 7)构造返回结果
|
|
|
|
JSONObject dataMap = new JSONObject();
|
|
|
|
dataMap.put("total", searchResult.getTotal());
|
|
|
|
dataMap.put("page", searchResult.getPage());
|
|
|
|
dataMap.put("page_size", searchParam.getSize());
|
|
|
|
dataMap.put("page_total", searchResult.getTotalPage());
|
|
|
|
dataMap.put("product_list", searchServiceHelper.getProductMapList(searchResult.getResultList(), Arrays.asList("phrase")));
|
|
|
|
|
|
|
|
// 8)将结果存进缓存
|
|
|
|
searchCacheService.addJSONObjectToCache(cacheEnum, indexName, searchParam, dataMap);
|
|
|
|
return new SearchApiResult().setData(dataMap);
|
|
|
|
}
|
|
|
|
|
|
|
|
private QueryBuilder builderGoodProductQueryBuilder(Map<String, String> paramMap, List<String> recommendedSknList) {
|
|
|
|
QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();
|
|
|
|
FunctionScoreQueryBuilder functionScoreQueryBuilder = new FunctionScoreQueryBuilder(queryBuilder);
|
|
|
|
// 针对参数里第一个SKN加分
|
|
|
|
String productSkns = paramMap.get(SearchRequestParams.PARAM_SYNC_SKN);
|
|
|
|
if (!StringUtils.isBlank(productSkns)) {
|
|
|
|
functionScoreQueryBuilder.add(QueryBuilders.termsQuery("productSkn", productSkns.split(",")[0]), ScoreFunctionBuilders.weightFactorFunction(firstSknScore));
|
|
|
|
}
|
|
|
|
// 针对推荐出来的SKN做加分
|
|
|
|
if (recommendedSknList != null && !recommendedSknList.isEmpty()) {
|
|
|
|
Map<Integer, List<String>> recommondSknMap = this.splitProductSkns(recommendedSknList, maxCountPerGroup);
|
|
|
|
float currentGroupScore = recommendedSknMaxScore;
|
|
|
|
for (Map.Entry<Integer, List<String>> entry: recommondSknMap.entrySet()) {
|
|
|
|
functionScoreQueryBuilder.add(QueryBuilders.termsQuery("productSkn", entry.getValue()), ScoreFunctionBuilders.weightFactorFunction(currentGroupScore));
|
|
|
|
currentGroupScore = currentGroupScore - 10;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// 加上个性化打分
|
|
|
|
if (searchCommonHelper.isNeedPersonalSearch(paramMap)) {
|
|
|
|
personalVectorFeatureSearch.addPersonalizedScriptScore(functionScoreQueryBuilder, paramMap);
|
|
|
|
}
|
|
|
|
return functionScoreQueryBuilder;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 获取SKN相关的小分类
|
|
|
|
*
|
|
|
|
* @param productSkns
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
private List<Integer> getProductSknSmallSortIds(Map<String, String> paramMap, int maxCount) {
|
|
|
|
String productSkns = paramMap.get(SearchRequestParams.PARAM_SYNC_SKN);
|
|
|
|
if (StringUtils.isBlank(productSkns)) {
|
|
|
|
return new ArrayList<Integer>();
|
|
|
|
}
|
|
|
|
String[] productSknArray = productSkns.split(",");
|
|
|
|
SearchParam searchParam = new SearchParam();
|
|
|
|
// 1、设置过滤条件
|
|
|
|
BoolQueryBuilder boolFilter = QueryBuilders.boolQuery();
|
|
|
|
boolFilter.must(QueryBuilders.termsQuery("productSkn", productSknArray));
|
|
|
|
searchParam.setFiter(boolFilter);
|
|
|
|
// 2、设置聚合条件
|
|
|
|
final String aggName = "smallSortAgg";
|
|
|
|
TermsBuilder smallSortIdAgg = AggregationBuilders.terms(aggName).field("smallSortId").size(maxCount);
|
|
|
|
searchParam.setAggregationBuilders(Arrays.asList(smallSortIdAgg));
|
|
|
|
// 3、设置分页
|
|
|
|
searchParam.setPage(0);
|
|
|
|
searchParam.setSize(0);
|
|
|
|
searchParam.setOffset(0);
|
|
|
|
|
|
|
|
// 4、先从缓存中获取,如果能取到，则直接返回
|
|
|
|
JSONArray sknSmallSortIdJSONArray = searchCacheService.getJSONArrayFromCache(ISearchConstants.INDEX_NAME_PRODUCT_INDEX, searchParam);
|
|
|
|
if (sknSmallSortIdJSONArray != null) {
|
|
|
|
return this.jsonArrayToList(sknSmallSortIdJSONArray, Integer.class);
|
|
|
|
}
|
|
|
|
// 5、执行搜索
|
|
|
|
SearchResult searchResult = searchCommonService.doSearch(ISearchConstants.INDEX_NAME_PRODUCT_INDEX, searchParam);
|
|
|
|
if (searchResult == null || searchResult.getAggMaps() == null || searchResult.getAggMaps().get("smallSortAgg") == null) {
|
|
|
|
return new ArrayList<Integer>();
|
|
|
|
}
|
|
|
|
sknSmallSortIdJSONArray = new JSONArray();
|
|
|
|
MultiBucketsAggregation aggregation = (MultiBucketsAggregation) searchResult.getAggMaps().get(aggName);
|
|
|
|
Iterator<? extends Bucket> smallSortIdIterator = aggregation.getBuckets().iterator();
|
|
|
|
while (smallSortIdIterator.hasNext()) {
|
|
|
|
Bucket smallSortIdBucket = smallSortIdIterator.next();
|
|
|
|
if (StringUtils.isNumeric(smallSortIdBucket.getKeyAsString())) {
|
|
|
|
sknSmallSortIdJSONArray.add(Integer.valueOf(smallSortIdBucket.getKeyAsString()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
searchCacheService.addJSONArrayToCache(ISearchConstants.INDEX_NAME_PRODUCT_INDEX, searchParam, sknSmallSortIdJSONArray);
|
|
|
|
return this.jsonArrayToList(sknSmallSortIdJSONArray, Integer.class);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 有好货默认的过滤规则
|
|
|
|
*
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
private BoolQueryBuilder getDefaultBoolQueryBuilder() {
|
|
|
|
BoolQueryBuilder boolFilter = QueryBuilders.boolQuery();
|
|
|
|
boolFilter.mustNot(QueryBuilders.termsQuery("isSeckill", "Y"));
|
|
|
|
boolFilter.mustNot(QueryBuilders.termsQuery("isGlobal", "Y"));
|
|
|
|
boolFilter.must(QueryBuilders.termQuery("status", 1));
|
|
|
|
boolFilter.must(QueryBuilders.termQuery("isOutlets", 2));
|
|
|
|
boolFilter.must(QueryBuilders.termQuery("attribute", 1));
|
|
|
|
// 默认推库存>2,非断码，并且短评存在的数据
|
|
|
|
boolFilter.must(QueryBuilders.rangeQuery("storageNum").gte(2));
|
|
|
|
boolFilter.must(QueryBuilders.rangeQuery("breakingRate").lt(50));
|
|
|
|
boolFilter.must(QueryBuilders.rangeQuery("basePinRatio").lt(3.5));
|
|
|
|
boolFilter.must(QueryBuilders.termQuery("isPhraseExist", "Y"));
|
|
|
|
return boolFilter;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 每个品类为用户推荐maxSize个SKN
|
|
|
|
*
|
|
|
|
* @param smallSortIds
|
|
|
|
* @param maxSize
|
|
|
|
* @param paramMap
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
private List<String> getRecommondedSkns(List<Integer> smallSortIds, int maxSizePerSort, Map<String, String> paramMap) {
|
|
|
|
// 1、如果品类为空，则直接返回
|
|
|
|
if (smallSortIds == null || smallSortIds.isEmpty()) {
|
|
|
|
return new ArrayList<String>();
|
|
|
|
}
|
|
|
|
SearchParam searchParam = new SearchParam();
|
|
|
|
|
|
|
|
// 2、构造filter
|
|
|
|
BoolQueryBuilder boolFilter = this.getDefaultBoolQueryBuilder();
|
|
|
|
boolFilter.must(QueryBuilders.termsQuery("smallSortId", smallSortIds));
|
|
|
|
searchParam.setFiter(boolFilter);
|
|
|
|
|
|
|
|
// 3、构造query
|
|
|
|
FunctionScoreQueryBuilder functionScoreQueryBuilder = new FunctionScoreQueryBuilder(QueryBuilders.matchAllQuery());
|
|
|
|
// 针对看过的SKN做加分
|
|
|
|
String productSkns = paramMap.get(SearchRequestParams.PARAM_SYNC_SKN);
|
|
|
|
if (!StringUtils.isBlank(productSkns)) {
|
|
|
|
functionScoreQueryBuilder.add(QueryBuilders.termsQuery("productSkn", productSkns.split(",")), ScoreFunctionBuilders.weightFactorFunction(100));
|
|
|
|
}
|
|
|
|
// 加上个性化打分
|
|
|
|
if (searchCommonHelper.isNeedPersonalSearch(paramMap)) {
|
|
|
|
personalVectorFeatureSearch.addPersonalizedScriptScore(functionScoreQueryBuilder, paramMap);
|
|
|
|
}
|
|
|
|
searchParam.setQuery(functionScoreQueryBuilder);
|
|
|
|
|
|
|
|
// 4、设置聚合条件
|
|
|
|
final String firstAggName = "firstAgg";
|
|
|
|
String order = "_score:desc";
|
|
|
|
String sortField = order.split(":")[0];
|
|
|
|
SortOrder sortOrder = order.split(":")[1].equals("desc") ? SortOrder.DESC : SortOrder.ASC;
|
|
|
|
List<AbstractAggregationBuilder> list = new ArrayList<AbstractAggregationBuilder>();
|
|
|
|
// 4.1）构造父聚合:品牌或品类聚合【同时按子聚合的sort字段排序】
|
|
|
|
TermsBuilder parentAggregationBuilder = AggregationBuilders.terms(firstAggName).field("smallSortId").size(smallSortIds.size());
|
|
|
|
// 4.2）添加子聚合:取得分最大的值
|
|
|
|
parentAggregationBuilder.subAggregation(AggregationBuilders.max("sort").field(sortField));
|
|
|
|
// 4.3）添加孙聚合：取打分最高的一个product
|
|
|
|
parentAggregationBuilder.subAggregation(AggregationBuilders.topHits("product").addSort(SortBuilders.fieldSort(sortField).order(sortOrder)).setSize(maxSizePerSort));
|
|
|
|
list.add(parentAggregationBuilder);
|
|
|
|
searchParam.setAggregationBuilders(list);
|
|
|
|
|
|
|
|
// 5、设置分页
|
|
|
|
searchParam.setPage(0);
|
|
|
|
searchParam.setSize(0);
|
|
|
|
searchParam.setOffset(0);
|
|
|
|
|
|
|
|
// 6、先从缓存中获取,如果能取到，则直接返回
|
|
|
|
JSONArray recommendedSknJSONArray = searchCacheService.getJSONArrayFromCache(ISearchConstants.INDEX_NAME_PRODUCT_INDEX, searchParam);
|
|
|
|
if (recommendedSknJSONArray != null) {
|
|
|
|
return this.jsonArrayToList(recommendedSknJSONArray, String.class);
|
|
|
|
}
|
|
|
|
// 7、执行搜索,并构造返回结果
|
|
|
|
final String indexName = ISearchConstants.INDEX_NAME_PRODUCT_INDEX;
|
|
|
|
SearchResult searchResult = searchCommonService.doSearch(indexName, searchParam);
|
|
|
|
if (searchResult == null || searchResult.getAggMaps() == null) {
|
|
|
|
return new ArrayList<String>();
|
|
|
|
}
|
|
|
|
Map<String, Aggregation> aggMaps = searchResult.getAggMaps();
|
|
|
|
if (!aggMaps.containsKey(firstAggName)) {
|
|
|
|
return new ArrayList<String>();
|
|
|
|
}
|
|
|
|
List<String> recommendedSknList = this.getRecommendedSknList((MultiBucketsAggregation) aggMaps.get(firstAggName));
|
|
|
|
recommendedSknJSONArray = new JSONArray();
|
|
|
|
for (String recommendedSkn : recommendedSknList) {
|
|
|
|
recommendedSknJSONArray.add(recommendedSkn);
|
|
|
|
}
|
|
|
|
searchCacheService.addJSONArrayToCache(indexName, searchParam, recommendedSknJSONArray);
|
|
|
|
return this.jsonArrayToList(recommendedSknJSONArray, String.class);
|
|
|
|
}
|
|
|
|
|
|
|
|
private <T> List<T> jsonArrayToList(JSONArray jsonArray, Class<T> clazz) {
|
|
|
|
return JSONObject.parseArray(jsonArray.toJSONString(), clazz);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 分组
|
|
|
|
*
|
|
|
|
* @param recommendedSknList
|
|
|
|
* @param maxGroupCount
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
private Map<Integer, List<String>> splitProductSkns(List<String> recommendedSknList, int maxCountPerGroup) {
|
|
|
|
int maxSize = recommendedSknList.size();
|
|
|
|
int groupSize = maxSize / maxCountPerGroup;
|
|
|
|
if (maxSize % maxCountPerGroup > 0) {
|
|
|
|
groupSize = groupSize + 1;
|
|
|
|
}
|
|
|
|
Map<Integer, List<String>> result = new HashMap<Integer, List<String>>();
|
|
|
|
for (int i = 0; i < groupSize; i++) {
|
|
|
|
int fromIndex = i * maxCountPerGroup;
|
|
|
|
int toIndex = (i + 1) * maxCountPerGroup;
|
|
|
|
result.put(i, recommendedSknList.subList(fromIndex, toIndex > maxSize ? maxSize : toIndex));
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
private List<String> getRecommendedSknList(MultiBucketsAggregation aggregation) {
|
|
|
|
Iterator<? extends Bucket> itAgg = aggregation.getBuckets().iterator();
|
|
|
|
// 获取聚合出来的商品
|
|
|
|
List<String> recommendedSknList = new ArrayList<String>();
|
|
|
|
while (itAgg.hasNext()) {
|
|
|
|
Bucket lt = itAgg.next();
|
|
|
|
if (lt.getAggregations().getAsMap().containsKey("product")) {
|
|
|
|
TopHits topHits = lt.getAggregations().get("product");
|
|
|
|
if (topHits != null) {
|
|
|
|
SearchHits hits = topHits.getHits();
|
|
|
|
for (SearchHit hit : hits.getHits()) {
|
|
|
|
recommendedSknList.add("" + hit.getSource().get("productSkn"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Collections.shuffle(recommendedSknList);
|
|
|
|
return recommendedSknList;
|
|
|
|
}
|
|
|
|
|
|
|
|
public static void main(String[] args) {
|
|
|
|
List<String> list = new ArrayList<String>();
|
|
|
|
for (int i = 1; i <= 99; i++) {
|
|
|
|
list.add(i+"");
|
|
|
|
}
|
|
|
|
Map<Integer, List<String>> results = new GoodProductListService().splitProductSkns(list, 20);
|
|
|
|
for (Map.Entry<Integer, List<String>> entry : results.entrySet()) {
|
|
|
|
System.out.println(entry.getKey() + "_" + entry.getValue());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
} |
...
|
...
|
|
