day06

  feture 检索功能；查询置顶三级分类

model/src/main/java/com/atguigu/tingshu/model/search/AttributeValueIndex.java

@@ -9,10 +9,12 @@ import org.springframework.data.elasticsearch.annotations.FieldType;
 @Schema(description = "专辑属性值")
 public class AttributeValueIndex {
 
+	//讲播形式
 	@Field(type = FieldType.Long)
 	private Long attributeId;
 
+	//单人 多人
 	@Field(type = FieldType.Long)
 	private Long valueId;
 
-}
+}

model/src/main/java/com/atguigu/tingshu/query/search/AlbumIndexQuery.java

@@ -21,7 +21,7 @@ public class AlbumIndexQuery {
 	@Schema(description = "三级分类")
 	private Long category3Id;
 
-	@Schema(description = "属性（属性id:属性值id）")
+	@Schema(description = "属性（标签id:标签值id）")
 	private List<String> attributeList;
 
 	// order=1:asc  排序规则   0:asc
@@ -30,4 +30,4 @@ public class AlbumIndexQuery {
 
 	private Integer pageNo = 1;//分页信息
 	private Integer pageSize = 10;
-}
+}

service/service-album/src/main/java/com/atguigu/tingshu/album/api/BaseCategoryApiController.java

@@ -4,6 +4,7 @@ import com.alibaba.fastjson.JSONObject;
 import com.atguigu.tingshu.album.service.BaseCategoryService;
 import com.atguigu.tingshu.common.result.Result;
 import com.atguigu.tingshu.model.album.BaseAttribute;
+import com.atguigu.tingshu.model.album.BaseCategory3;
 import com.atguigu.tingshu.model.album.BaseCategoryView;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -63,5 +64,18 @@ public class BaseCategoryApiController {
         BaseCategoryView baseCategoryView = baseCategoryService.getCategoryView(category3Id);
         return Result.ok(baseCategoryView);
     }
+
+    /**
+     * 根据1级分类ID查询置顶7个三级分类列表
+     * @param category1Id
+     * @return
+     */
+    @Operation(summary = "根据1级分类ID查询置顶7个三级分类列表")
+    @GetMapping("/category/findTopBaseCategory3/{category1Id}")
+    public Result<List<BaseCategory3>> findTopBaseCategory3(@PathVariable("category1Id") Long category1Id) {
+        List<BaseCategory3> list = baseCategoryService.findTopBaseCategory3(category1Id);
+        return Result.ok(list);
+    }
+
 }
 

service/service-album/src/main/java/com/atguigu/tingshu/album/service/BaseCategoryService.java

@@ -3,6 +3,7 @@ package com.atguigu.tingshu.album.service;
 import com.alibaba.fastjson.JSONObject;
 import com.atguigu.tingshu.model.album.BaseAttribute;
 import com.atguigu.tingshu.model.album.BaseCategory1;
+import com.atguigu.tingshu.model.album.BaseCategory3;
 import com.atguigu.tingshu.model.album.BaseCategoryView;
 import com.baomidou.mybatisplus.extension.service.IService;
 
@@ -24,4 +25,11 @@ public interface BaseCategoryService extends IService<BaseCategory1> {
     List<BaseAttribute> findAttributeByCategory1Id(Long category1Id);
 
     BaseCategoryView getCategoryView(Long category3Id);
+
+    /**
+     * 根据1级分类ID查询置顶7个三级分类列表
+     * @param category1Id
+     * @return
+     */
+    List<BaseCategory3> findTopBaseCategory3(Long category1Id);
 }

service/service-album/src/main/java/com/atguigu/tingshu/album/service/impl/BaseCategoryServiceImpl.java

@@ -1,11 +1,11 @@
 package com.atguigu.tingshu.album.service.impl;
 
+import cn.hutool.core.collection.CollUtil;
 import com.alibaba.fastjson.JSONObject;
 import com.atguigu.tingshu.album.mapper.*;
 import com.atguigu.tingshu.album.service.BaseCategoryService;
-import com.atguigu.tingshu.model.album.BaseAttribute;
-import com.atguigu.tingshu.model.album.BaseCategory1;
-import com.atguigu.tingshu.model.album.BaseCategoryView;
+import com.atguigu.tingshu.model.album.*;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
@@ -35,7 +35,6 @@ public class BaseCategoryServiceImpl extends ServiceImpl<BaseCategory1Mapper, Ba
     private BaseAttributeMapper baseAttributeMapper;
 
 
-
     /**
      * 查询所有1,2,3级分类数据
      *
@@ -99,6 +98,7 @@ public class BaseCategoryServiceImpl extends ServiceImpl<BaseCategory1Mapper, Ba
 
     /**
      * 根据一级分类Id获取分类标签以及标签值
+     *
      * @param category1Id
      * @return
      */
@@ -109,6 +109,7 @@ public class BaseCategoryServiceImpl extends ServiceImpl<BaseCategory1Mapper, Ba
 
     /**
      * 根据分类视图ID查询分类视图对象
+     *
      * @param category3Id
      * @return
      */
@@ -116,4 +117,35 @@ public class BaseCategoryServiceImpl extends ServiceImpl<BaseCategory1Mapper, Ba
     public BaseCategoryView getCategoryView(Long category3Id) {
         return baseCategoryViewMapper.selectById(category3Id);
     }
+
+    /**
+     * 根据1级分类ID查询置顶7个三级分类列表
+     *
+     * @param category1Id
+     * @return
+     */
+    @Override
+    public List<BaseCategory3> findTopBaseCategory3(Long category1Id) {
+        //1.根据1级分类ID查询包含二级分类列表 得到二级分类ID列表
+        List<BaseCategory2> baseCategory2List = baseCategory2Mapper.selectList(
+                new LambdaQueryWrapper<BaseCategory2>()
+                        .eq(BaseCategory2::getCategory1Id, category1Id)
+                        .select(BaseCategory2::getId)
+        );
+        if (CollUtil.isNotEmpty(baseCategory2List)) {
+            List<Long> category2IdList = baseCategory2List
+                    .stream()
+                    .map(BaseCategory2::getId)
+                    .collect(Collectors.toList());
+            //2.根据二级分类ID列表查询置顶7个三级分类列表
+            LambdaQueryWrapper<BaseCategory3> queryWrapper = new LambdaQueryWrapper<>();
+            queryWrapper.eq(BaseCategory3::getIsTop, 1);
+            queryWrapper.in(BaseCategory3::getCategory2Id, category2IdList);
+            queryWrapper.orderByAsc(BaseCategory3::getOrderNum);
+            queryWrapper.last("limit 7");
+            List<BaseCategory3> list = baseCategory3Mapper.selectList(queryWrapper);
+            return list;
+        }
+        return null;
+    }
 }

service/service-search/src/main/java/com/atguigu/tingshu/search/api/SearchApiController.java

@@ -1,14 +1,13 @@
 package com.atguigu.tingshu.search.api;
 
 import com.atguigu.tingshu.common.result.Result;
+import com.atguigu.tingshu.query.search.AlbumIndexQuery;
 import com.atguigu.tingshu.search.service.SearchService;
+import com.atguigu.tingshu.vo.search.AlbumSearchResponseVo;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.PathVariable;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.*;
 
 @Tag(name = "搜索专辑管理")
 @RestController
@@ -39,5 +38,20 @@ public class SearchApiController {
         searchService.lowerAlbum(albumId);
         return Result.ok();
     }
+
+
+
+    /**
+     * 站内条件检索专辑接口
+     *
+     * @param albumIndexQuery
+     * @return
+     */
+    @Operation(summary = "站内条件检索专辑接口")
+    @PostMapping("/albumInfo")
+    public Result<AlbumSearchResponseVo> search(@RequestBody AlbumIndexQuery albumIndexQuery) {
+        AlbumSearchResponseVo vo = searchService.search(albumIndexQuery);
+        return Result.ok(vo);
+    }
 }
 

service/service-search/src/main/java/com/atguigu/tingshu/search/service/SearchService.java

@@ -1,5 +1,11 @@
 package com.atguigu.tingshu.search.service;
 
+import co.elastic.clients.elasticsearch.core.SearchRequest;
+import co.elastic.clients.elasticsearch.core.SearchResponse;
+import com.atguigu.tingshu.model.search.AlbumInfoIndex;
+import com.atguigu.tingshu.query.search.AlbumIndexQuery;
+import com.atguigu.tingshu.vo.search.AlbumSearchResponseVo;
+
 public interface SearchService {
 
 
@@ -14,4 +20,27 @@ public interface SearchService {
      * @param albumId
      */
     void lowerAlbum(Long albumId);
+
+
+    /**
+     * 多条件条件分页检索
+     * @param albumIndexQuery
+     * @return
+     */
+    AlbumSearchResponseVo search(AlbumIndexQuery albumIndexQuery);
+
+    /**
+     * 基于检索条件封装完整检索请求对象
+     * @param albumIndexQuery
+     * @return
+     */
+    SearchRequest buildDSL(AlbumIndexQuery albumIndexQuery);
+
+    /**
+     * 解析ES响应结果封装自定义VO
+     * @param searchResponse
+     * @param albumIndexQuery
+     * @return
+     */
+    AlbumSearchResponseVo parseResult(SearchResponse<AlbumInfoIndex> searchResponse, AlbumIndexQuery albumIndexQuery);
 }

service/service-search/src/main/java/com/atguigu/tingshu/search/service/impl/SearchServiceImpl.java

@@ -4,22 +4,34 @@ import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.lang.Assert;
 import cn.hutool.core.util.RandomUtil;
+import co.elastic.clients.elasticsearch.ElasticsearchClient;
+import co.elastic.clients.elasticsearch._types.SortOrder;
+import co.elastic.clients.elasticsearch._types.query_dsl.BoolQuery;
+import co.elastic.clients.elasticsearch.core.SearchRequest;
+import co.elastic.clients.elasticsearch.core.SearchResponse;
+import co.elastic.clients.elasticsearch.core.search.Hit;
+import co.elastic.clients.elasticsearch.core.search.HitsMetadata;
 import com.atguigu.tingshu.album.AlbumFeignClient;
 import com.atguigu.tingshu.model.album.AlbumAttributeValue;
 import com.atguigu.tingshu.model.album.AlbumInfo;
 import com.atguigu.tingshu.model.album.BaseCategoryView;
 import com.atguigu.tingshu.model.search.AlbumInfoIndex;
 import com.atguigu.tingshu.model.search.AttributeValueIndex;
+import com.atguigu.tingshu.query.search.AlbumIndexQuery;
 import com.atguigu.tingshu.search.repository.AlbumInfoIndexRepository;
 import com.atguigu.tingshu.search.service.SearchService;
 import com.atguigu.tingshu.user.client.UserFeignClient;
+import com.atguigu.tingshu.vo.search.AlbumInfoIndexVo;
+import com.atguigu.tingshu.vo.search.AlbumSearchResponseVo;
 import com.atguigu.tingshu.vo.user.UserInfoVo;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import java.math.BigDecimal;
 import java.util.List;
+import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Executor;
 import java.util.stream.Collectors;
@@ -43,6 +55,9 @@ public class SearchServiceImpl implements SearchService {
     @Autowired  //先按类型注入 再按名称注入
     private Executor threadPoolTaskExecutor;
 
+    @Autowired
+    private ElasticsearchClient elasticsearchClient;
+
     //@Autowired
     //@Qualifier("threadPoolTaskExecutor")
     //private Executor executor;
@@ -57,6 +72,7 @@ public class SearchServiceImpl implements SearchService {
      */
     @Override
     public void upperAlbum(Long albumId) {
+        log.info("主线程:{}，专辑索引库对象", Thread.currentThread().getName());
         //1.创建索引库对象
         AlbumInfoIndex albumInfoIndex = new AlbumInfoIndex();
 
@@ -64,6 +80,7 @@ public class SearchServiceImpl implements SearchService {
         CompletableFuture<AlbumInfo> albumInfoCompletableFuture = CompletableFuture.supplyAsync(() -> {
             //2.1 远程调用专辑服务根据专辑ID查询专辑信息包含标签列表
             AlbumInfo albumInfo = albumFeignClient.getAlbumInfo(albumId).getData();
+            log.info("子线程:{}，执行查询专辑", Thread.currentThread().getName());
             Assert.notNull(albumInfo, "专辑:{}不存在", albumId);
             //2.2 为索引库对象中属性赋值
             BeanUtil.copyProperties(albumInfo, albumInfoIndex);
@@ -81,6 +98,7 @@ public class SearchServiceImpl implements SearchService {
 
         //3.封装专辑索引库分类信息
         CompletableFuture<Void> categoryCompletableFuture = albumInfoCompletableFuture.thenAcceptAsync(albumInfo -> {
+            log.info("子线程:{}，执行查询分类", Thread.currentThread().getName());
             BaseCategoryView categoryView = albumFeignClient.getCategoryView(albumInfo.getCategory3Id()).getData();
             Assert.notNull(categoryView, "专辑分类:{}不存在", albumInfo.getCategory3Id());
             albumInfoIndex.setCategory1Id(categoryView.getCategory1Id());
@@ -89,12 +107,13 @@ public class SearchServiceImpl implements SearchService {
 
         //4.封装专辑索引库主播信息
         CompletableFuture<Void> userCompletableFuture = albumInfoCompletableFuture.thenAcceptAsync(albumInfo -> {
+            log.info("子线程:{}，执行查询用户", Thread.currentThread().getName());
             UserInfoVo userInfoVo = userFeignClient.getUserInfoVo(albumInfo.getUserId()).getData();
             Assert.notNull(userInfoVo, "用户:{}不存在", albumInfo.getUserId());
             albumInfoIndex.setAnnouncerName(userInfoVo.getNickname());
         }, threadPoolTaskExecutor);
 
-        //5.封装专辑索引库统计信息 暂时采用随机生成方式
+        //5.封装专辑索引库统计信息 暂时采用随机生成方式 TODO 上线后需要实际查询统计数值
         CompletableFuture<Void> statCompletableFuture = CompletableFuture.runAsync(() -> {
             //5.1 随机产生四个数值对应 播放数，订阅数，购买数，评论数
             int num1 = RandomUtil.randomInt(1000, 5000);
@@ -129,10 +148,179 @@ public class SearchServiceImpl implements SearchService {
 
     /**
      * 下架索引库专辑
+     *
      * @param albumId
      */
     @Override
     public void lowerAlbum(Long albumId) {
         albumInfoIndexRepository.deleteById(albumId);
     }
+
+    /**
+     * 多条件条件分页检索
+     *
+     * @param albumIndexQuery
+     * @return
+     */
+    @Override
+    public AlbumSearchResponseVo search(AlbumIndexQuery albumIndexQuery) {
+        try {
+            //一、构建检索请求对象
+            SearchRequest searchRequest = this.buildDSL(albumIndexQuery);
+            System.err.println("本次检索DSL：");
+            System.err.println(searchRequest.toString());
+            //二、调用ES客户端执行检索
+            SearchResponse<AlbumInfoIndex> searchResponse = elasticsearchClient.search(searchRequest, AlbumInfoIndex.class);
+            //三、解析封装ES响应结果
+            return this.parseResult(searchResponse, albumIndexQuery);
+        } catch (Exception e) {
+            log.error("[检索服务]专辑检索异常：{}", e);
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static final String INDEX_NAME = "albuminfo";
+
+    /**
+     * 基于检索条件封装完整检索请求对象
+     *
+     * @param albumIndexQuery
+     * @return
+     */
+    @Override
+    public SearchRequest buildDSL(AlbumIndexQuery albumIndexQuery) {
+        //1.创建检索请求 构建器对象->封装请求路径索引名称以及完整请求体参数
+        SearchRequest.Builder builder = new SearchRequest.Builder();
+        builder.index(INDEX_NAME);
+        //2.封装请求体参数 query。通过布尔查询封装 三大条件：1.关键字  2.分类  3.标签
+        //2.1 创建封装三大条件bool查询对象
+        BoolQuery.Builder allConditionBoolQueryBuilder = new BoolQuery.Builder();
+        //2.2 设置关键字条件查询
+        String keyword = albumIndexQuery.getKeyword();
+        if (StringUtils.isNotBlank(keyword)) {
+            allConditionBoolQueryBuilder.must(m -> m.bool(
+                    b -> b.should(s -> s.match(m1 -> m1.field("albumTitle").query(keyword)))
+                            .should(s -> s.match(m1 -> m1.field("albumIntro").query(keyword)))
+                            .should(s -> s.term(t -> t.field("announcerName").value(keyword)))
+            ));
+        }
+        //2.3 设置分类条件过滤
+        if (albumIndexQuery.getCategory1Id() != null) {
+            allConditionBoolQueryBuilder.filter(f -> f.term(t -> t.field("category1Id").value(albumIndexQuery.getCategory1Id())));
+        }
+        if (albumIndexQuery.getCategory2Id() != null) {
+            allConditionBoolQueryBuilder.filter(f -> f.term(t -> t.field("category2Id").value(albumIndexQuery.getCategory2Id())));
+        }
+        if (albumIndexQuery.getCategory3Id() != null) {
+            allConditionBoolQueryBuilder.filter(f -> f.term(t -> t.field("category3Id").value(albumIndexQuery.getCategory3Id())));
+        }
+
+        //2.4 设置标签条件过滤 可能有多组标签 每一组标签条件产生一个嵌套查询
+        List<String> attributeList = albumIndexQuery.getAttributeList();
+        if (CollUtil.isNotEmpty(attributeList)) {
+            //2.4.1 遍历标签列表 每遍历一次设置过滤Nested查询
+            for (String attribute : attributeList) {
+                //标签条件=标签ID:标签值ID
+                String[] split = attribute.split(":");
+                if (split != null && split.length == 2) {
+                    allConditionBoolQueryBuilder.filter(f -> f.nested(
+                            n -> n.path("attributeValueIndexList")
+                                    .query(q -> q.bool(
+                                            b -> b.must(m -> m.term(t -> t.field("attributeValueIndexList.attributeId").value(split[0])))
+                                                    .must(m -> m.term(t -> t.field("attributeValueIndexList.valueId").value(split[1])))
+                                    ))
+                    ));
+                }
+            }
+        }
+        //2.5 将三大条件的布尔查询对象设置到"query"中
+        builder.query(allConditionBoolQueryBuilder.build()._toQuery());
+        //2.2 封装分页条件 from=起始文档offset size=页大小
+        Integer pageNo = albumIndexQuery.getPageNo();
+        Integer pageSize = albumIndexQuery.getPageSize();
+        Integer from = (pageNo - 1) * pageSize;
+        builder.from(from).size(pageSize);
+
+        //2.3 封装排序条件 sort
+        //2.3.1 获取排序条件 形式=>字段标识1/2/3:asc/desc   1：综合排序  2：发布时间  3：播放量
+        String order = albumIndexQuery.getOrder();
+        if (StringUtils.isNotBlank(order)) {
+            //2.3.2 如果有需要自定义排序，才设置请求参数:sort
+            String[] split = order.split(":");
+            if (split != null && split.length == 2) {
+                //2.3.3 得到排序字段 跟 排序方式
+                String sortField = "";
+                switch (split[0]) {
+                    case "1":
+                        sortField = "hotScore";
+                        break;
+                    case "2":
+                        sortField = "playStatNum";
+                        break;
+                    case "3":
+                        sortField = "createTime";
+                        break;
+                }
+                String finalSortField = sortField;
+                builder.sort(s -> s.field(f -> f.field(finalSortField).order(split[1].equals("desc") ? SortOrder.Desc : SortOrder.Asc)));
+            }
+        }
+        //2.4 封装高亮条件 highlight
+        if (StringUtils.isNotBlank(keyword)) {
+            builder.highlight(h -> h.fields("albumTitle", f -> f.preTags("<font style='color:red'>").postTags("</font>")));
+        }
+        //2.5 设置文档响应字段
+        builder.source(s -> s.filter(f -> f.excludes("attributeValueIndexList", "hotScore", "commentStatNum", "buyStatNum", "subscribeStatNum", "announcerName")));
+        //3.基于构建器对象产生检索请求对象
+        return builder.build();
+    }
+
+    /**
+     * 解析ES响应结果封装自定义VO
+     *
+     * @param searchResponse
+     * @param albumIndexQuery
+     * @return
+     */
+    @Override
+    public AlbumSearchResponseVo parseResult(SearchResponse<AlbumInfoIndex> searchResponse, AlbumIndexQuery albumIndexQuery) {
+        //1.创建响应VO对象
+        AlbumSearchResponseVo vo = new AlbumSearchResponseVo();
+        //2.封装VO中分页信息
+        //2.1 从检索条件对象中获取页码、页大小
+        Integer pageNo = albumIndexQuery.getPageNo();
+        Integer pageSize = albumIndexQuery.getPageSize();
+        //2.2 从响应结果对象中获取总记录数，计算总页数
+        HitsMetadata<AlbumInfoIndex> hits = searchResponse.hits();
+        long total = hits.total().value();
+        long totalPage = total % pageSize == 0 ? total / pageSize : total / pageSize + 1;
+
+        vo.setPageNo(pageNo);
+        vo.setPageSize(pageSize);
+        vo.setTotal(total);
+        vo.setTotalPages(totalPage);
+        //3.封装VO中业务数据集合
+        //3.1 获取检索结果中hits对象中包含hits数组
+        List<Hit<AlbumInfoIndex>> hitList = hits.hits();
+
+        //3.2 遍历hits数组，得到文档对象中_source对应文档对象
+        if (CollUtil.isNotEmpty(hitList)) {
+            List<AlbumInfoIndexVo> albumInfoVoList = hitList
+                    .stream()
+                    .map(hit -> {
+                        AlbumInfoIndex albumInfoIndex = hit.source();
+                        //3.3 如果有高亮字段，则替换文档对象中对应字段的值
+                        Map<String, List<String>> map = hit.highlight();
+                        if (CollUtil.isNotEmpty(map)) {
+                            List<String> list = map.get("albumTitle");
+                            String highLigthText = list.get(0);
+                            albumInfoIndex.setAlbumTitle(highLigthText);
+                        }
+                        return BeanUtil.copyProperties(albumInfoIndex, AlbumInfoIndexVo.class);
+                    }).collect(Collectors.toList());
+            vo.setList(albumInfoVoList);
+        }
+        //4.响应vo
+        return vo;
+    }
 }