182、商城业务-检索服务-SearchResponse分析&封装

/**
     * 构建结果数据
     * @param response
     * @return
     */
    private SearchResult buildSearchResult(SearchParam param,SearchResponse response) {
        SearchResult result = new SearchResult();

        SearchHits hits = response.getHits();

//        SearchHit[] subHits = hits.getHits();
        List<SkuEsModel> esModels= new ArrayList<>();
        if(hits.getHits() != null && hits.getHits().length > 0){
            for(SearchHit hit : hits.getHits()) {
                String sourceAsString = hit.getSourceAsString();
                SkuEsModel esModel = JSON.parseObject(sourceAsString, SkuEsModel.class);
                esModels.add(esModel);
            }

//            skuEsModels = Arrays.asList(subHits).stream().map(subHit -> {
//                String sourceAsString = subHit.getSourceAsString();
//                SkuEsModel skuEsModel = JSON.parseObject(sourceAsString, SkuEsModel.class);
//                if (!StringUtils.isEmpty(param.getKeyword())) {
//                    HighlightField skuTitle = subHit.getHighlightFields().get("skuTitle");
//                    String skuTitleHighLight = skuTitle.getFragments()[0].string();
//                    skuEsModel.setSkuTitle(skuTitleHighLight);
//                }
//                return skuEsModel;
//            }).collect(Collectors.toList());

        }
        //1.返回所查询到的所有商品
        result.setProducts(esModels);

        //2.当前所有商品所涉及到的所有属性信息
        List<SearchResult.AttrVo> attrVos = new ArrayList<>();
        ParsedNested attr_agg = response.getAggregations().get("attr_agg");
        ParsedLongTerms attr_id_agg = attr_agg.getAggregations().get("attr_id_agg");
        for(Terms.Bucket bucket : attr_id_agg.getBuckets()) {
            SearchResult.AttrVo attrVo = new SearchResult.AttrVo();
            // 1、得到属性的id
            long attrId = bucket.getKeyAsNumber().longValue();
            // 2、得到属性的名字
            String attrName = ((ParsedStringTerms) bucket.getAggregations().get("attr_name_agg")).getBuckets().get(0).getKeyAsString();
            // 3、得到属性所有的值
            List<String> attrValues = ((ParsedStringTerms) bucket.getAggregations().get("attr_value_agg")).getBuckets().stream().map(item -> {
                String keyAsString = ((Terms.Bucket) item).getKeyAsString();
                return keyAsString;
            }).collect(Collectors.toList());

            attrVo.setAttrId(attrId);
            attrVo.setAttrName(attrName);
            attrVo.setAttrValue(attrValues);

            attrVos.add(attrVo);
        }
        result.setAttrs(attrVos);

        //3.当前所有商品所涉及到的所有品牌信息
        List<SearchResult.BrandVo> brandVos = new ArrayList<>();
        ParsedLongTerms brand_agg = response.getAggregations().get("brand_agg");
        for(Terms.Bucket bucket : brand_agg.getBuckets()) {
            SearchResult.BrandVo brandVo = new SearchResult.BrandVo();
            // 1、得到品牌的id
            long brandId = bucket.getKeyAsNumber().longValue();
            // 2、得到品牌的名
            String brandName = ((ParsedStringTerms) bucket.getAggregations().get("brand_name_agg")).getBuckets().get(0).getKeyAsString();
            // 3、得到品牌的图片
            String brandImg = ((ParsedStringTerms) bucket.getAggregations().get("brand_img_agg")).getBuckets().get(0).getKeyAsString();
            brandVo.setBrandId(brandId);
            brandVo.setBrandName(brandName);
            brandVo.setBrandImg(brandImg);
            brandVos.add(brandVo);
        }
        result.setBrands(brandVos);

        //4.当前所有商品所涉及到的所有分类信息
        ParsedLongTerms catalog_agg = response.getAggregations().get("catalog_agg");

        List<SearchResult.CatalogVo> catalogVos = new ArrayList<>();
        List<? extends Terms.Bucket> buckets = catalog_agg.getBuckets();
        for(Terms.Bucket bucket : buckets) {
            SearchResult.CatalogVo catalogVo = new SearchResult.CatalogVo();
            //得到分类id
            String keyAsString = bucket.getKeyAsString();
            catalogVo.setCatalogId(Long.parseLong(keyAsString));
            //得到分类名
            ParsedStringTerms catalog_name_agg = bucket.getAggregations().get("catalog_name_agg");
            String catalog_name = catalog_name_agg.getBuckets().get(0).getKeyAsString();
            catalogVo.setCatalogName(catalog_name);
            catalogVos.add(catalogVo);
        }
        result.setCatalogs(catalogVos);
        //=========以上从聚合信息中获取===========
        //5.分页信息-页码
        result.setPageNum(param.getPageNum());
        //5.分页信息-总记录数
        long total = hits.getTotalHits().value;
        result.setTotal(total);
        //5.分页信息-总页码
        int totalPage=(int)total%EsConstant.PRODUCT_PAGESIZE == 0?(int)total/EsConstant.PRODUCT_PAGESIZE:(int)(total/EsConstant.PRODUCT_PAGESIZE+1);
        result.setTotalPages(totalPage);

        return null;
    }

 

**谷粒随享** ## 第7章 专辑/声音详情 **学习目标:** - 专辑详情业务需求 - 专辑服务 1.专辑信息 2.分类信息 3.统计信息 4,主播信息 - 搜索服务:汇总专辑详情数据 - 专辑包含**声音列表(付费标识动态展示)** - MongoDB文档型数据库应用 - 基于**MongoDB**存储用户对于声音**播放进度** - 基于Redis实现排行榜(将不同分类下包含各个维度热门专辑排行) # 1、专辑详情 ![详情-专辑详情和声音列表](assets/详情-专辑详情和声音列表.gif) 专辑详情页面渲染需要以下四项数据: - **albumInfo**:当前专辑信息 - **albumStatVo**:专辑统计信息 - **baseCategoryView**:专辑分类信息 - **announcer**:专辑主播信息 因此接下来,我们需要在**专辑微服务**、**用户微服务**中补充RestFul接口实现 并且 提供远程调用Feign API接口给**搜索微服务**来调用获取。 在专辑**搜索微服务**中编写控制器**汇总专辑详情**所需**数据**: 以下是详情需要获取到的数据集 1. 通过专辑Id 获取专辑数据{已存在} 2. 通过专辑Id 获取专辑统计信息**{不存在}** 3. 通过三级分类Id 获取到分类数据{已存在} 4. 通过用户Id 获取到主播信息{存在} ## 1.1 服务提供方提供接口 ### 1.1.1 根据专辑Id 获取专辑数据(已完成) ### 1.1.2 根据三级分类Id获取到分类信息(已完成) ### 1.1.3 根据用户Id 获取主播信息(已完成) ### 1.1.4 根据专辑Id 获取统计信息 &gt; YAPI接口地址:http://192.168.200.6:3000/project/11/interface/api/67 **AlbumInfoApiController** 控制器 ```java /** * 根据专辑ID查询专辑统计信息 * * @param albumId * @return */ @Operation(summary = &quot;根据专辑ID查询专辑统计信息&quot;) @GetMapping(&quot;/albumInfo/getAlbumStatVo/{albumId}&quot;) public Result&lt;AlbumStatVo&gt; getAlbumStatVo(@PathVariable Long albumId) { AlbumStatVo albumStatVo = albumInfoService.getAlbumStatVo(albumId); return Result.ok(albumStatVo); } ``` **AlbumInfoService**接口 ```java /** * 根据专辑ID查询专辑统计信息 * * @param albumId * @return */ AlbumStatVo getAlbumStatVo(Long albumId); ``` **AlbumInfoServiceImpl**实现类 ```java /** * 根据专辑ID查询专辑统计信息 * * @param albumId * @return */ @Override public AlbumStatVo getAlbumStatVo(Long albumId) { return albumInfoMapper.getAlbumStatVo(albumId); } ``` **albumInfoMapper.java** ```java /** * 根据专辑ID查询专辑统计信息 * * @param albumId * @return */ AlbumStatVo getAlbumStatVo(@Param(&quot;albumId&quot;) Long albumId); ``` **albumInfoMapper.xml** ```sql &lt;!--据专辑ID查询专辑统计信息--&gt; &lt;select id=&quot;getAlbumStatVo&quot; resultType=&quot;com.atguigu.tingshu.vo.album.AlbumStatVo&quot;&gt; select stat.album_id, max(if(stat.stat_type=&#39;0401&#39;, stat.stat_num, 0)) playStatNum, max(if(stat.stat_type=&#39;0402&#39;, stat.stat_num, 0)) subscribeStatNum, max(if(stat.stat_type=&#39;0403&#39;, stat.stat_num, 0)) buyStatNum, max(if(stat.stat_type=&#39;0404&#39;, stat.stat_num, 0)) commentStatNum from album_stat stat where stat.album_id = #{albumId} and stat.is_deleted = 0 group by stat.album_id &lt;/select&gt; ``` `service-album-client`模块**AlbumFeignClient** 接口中添加 ```java /** * 根据专辑ID查询专辑统计信息 * * @param albumId * @return */ @GetMapping(&quot;/albumInfo/getAlbumStatVo/{albumId}&quot;) public Result&lt;AlbumStatVo&gt; getAlbumStatVo(@PathVariable Long albumId); ``` **AlbumDegradeFeignClient**熔断类: ```java @Override public Result&lt;AlbumStatVo&gt; getAlbumStatVo(Long albumId) { log.error(&quot;[专辑模块]提供远程调用方法getAlbumStatVo服务降级&quot;); return null; } ``` ## 1.2 服务调用方汇总数据 回显时,后台需要提供将数据封装到map集合中; ```java result.put(&quot;albumInfo&quot;, albumInfo); 获取专辑信息 result.put(&quot;albumStatVo&quot;, albumStatVo); 获取专辑统计信息 result.put(&quot;baseCategoryView&quot;, baseCategoryView); 获取分类信息 result.put(&quot;announcer&quot;, userInfoVo); 获取主播信息 ``` &gt; YAPI接口地址:http://192.168.200.6:3000/project/11/interface/api/69 在`service-search` 微服务**itemApiController** 控制器中添加 ```java package com.atguigu.tingshu.search.api; import com.atguigu.tingshu.common.result.Result; import com.atguigu.tingshu.search.service.ItemService; 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 java.util.Map; @Tag(name = &quot;专辑详情管理&quot;) @RestController @RequestMapping(&quot;api/search&quot;) @SuppressWarnings({&quot;all&quot;}) public class itemApiController { @Autowired private ItemService itemService; /** * 根据专辑ID查询专辑详情相关数据 * * @param albumId * @return */ @Operation(summary = &quot;根据专辑ID查询专辑详情相关数据&quot;) @GetMapping(&quot;/albumInfo/{albumId}&quot;) public Result&lt;Map&lt;String, Object&gt;&gt; getItemInfo(@PathVariable Long albumId) { Map&lt;String, Object&gt; mapResult = itemService.getItemInfo(albumId); return Result.ok(mapResult); } } ``` 接口与实现 ```java package com.atguigu.tingshu.search.service; import java.util.Map; public interface ItemService { /** * 根据专辑ID查询专辑详情相关数据 * * @param albumId * @return */ Map&lt;String, Object&gt; getItemInfo(Long albumId); } ``` ```java package com.atguigu.tingshu.search.service.impl; import cn.hutool.core.lang.Assert; import com.atguigu.tingshu.album.AlbumFeignClient; import com.atguigu.tingshu.model.album.AlbumInfo; import com.atguigu.tingshu.model.album.BaseCategoryView; import com.atguigu.tingshu.search.service.ItemService; import com.atguigu.tingshu.user.client.UserFeignClient; import com.atguigu.tingshu.vo.album.AlbumStatVo; import com.atguigu.tingshu.vo.user.UserInfoVo; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import java.util.HashMap; import java.util.Map; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ThreadPoolExecutor; @Slf4j @Service @SuppressWarnings({&quot;all&quot;}) public class ItemServiceImpl implements ItemService { @Autowired private AlbumFeignClient albumFeignClient; @Autowired private UserFeignClient userFeignClient; @Autowired private ThreadPoolExecutor threadPoolExecutor; /** * 根据专辑ID查询专辑详情相关数据 * 1.albumInfo:当前专辑信息 * 2.albumStatVo:专辑统计信息 * 3.baseCategoryView:专辑分类信息 * 4.announcer:专辑主播信息 * * @param albumId * @return */ @Override public Map&lt;String, Object&gt; getItemInfo(Long albumId) { //1.创建响应结果Map对象 HashMap在多线程环境下并发读写线程不安全:导致key覆盖;导致死循环 //采用线程安全:ConcurrentHashMap Map&lt;String, Object&gt; mapResult = new ConcurrentHashMap&lt;&gt;(); //2.远程调用专辑服务获取专辑基本信息-封装albumInfo属性 CompletableFuture&lt;AlbumInfo&gt; albumInfoCompletableFuture = CompletableFuture.supplyAsync(() -&gt; { AlbumInfo albumInfo = albumFeignClient.getAlbumInfo(albumId).getData(); Assert.notNull(albumInfo, &quot;专辑:{}不存在&quot;, albumId); mapResult.put(&quot;albumInfo&quot;, albumInfo); return albumInfo; }, threadPoolExecutor); //3.远程调用专辑服务获取专辑统计信息-封装albumStatVo属性 CompletableFuture&lt;Void&gt; albumStatCompletableFuture = CompletableFuture.runAsync(() -&gt; { AlbumStatVo albumStatVo = albumFeignClient.getAlbumStatVo(albumId).getData(); Assert.notNull(albumStatVo, &quot;专辑统计信息:{}不存在&quot;, albumId); mapResult.put(&quot;albumStatVo&quot;, albumStatVo); }, threadPoolExecutor); //4.远程调用专辑服务获取专辑分类信息-封装baseCategoryView属性 CompletableFuture&lt;Void&gt; baseCategoryViewCompletableFuture = albumInfoCompletableFuture.thenAcceptAsync(albumInfo -&gt; { BaseCategoryView categoryView = albumFeignClient.getCategoryView(albumInfo.getCategory3Id()).getData(); Assert.notNull(categoryView, &quot;分类:{}不存在&quot;, albumInfo.getCategory3Id()); mapResult.put(&quot;baseCategoryView&quot;, categoryView); }, threadPoolExecutor); //5.远程调用用户服务获取主播信息-封装announcer属性 CompletableFuture&lt;Void&gt; announcerCompletableFuture = albumInfoCompletableFuture.thenAcceptAsync(albumInfo -&gt; { UserInfoVo userInfoVo = userFeignClient.getUserInfoVo(albumInfo.getUserId()).getData(); Assert.notNull(userInfoVo, &quot;用户:{}不存在&quot;, albumInfo.getUserId()); mapResult.put(&quot;announcer&quot;, userInfoVo); }, threadPoolExecutor); //6.组合异步任务,阻塞等待所有异步任务执行完毕 CompletableFuture.allOf( albumInfoCompletableFuture, albumStatCompletableFuture, baseCategoryViewCompletableFuture, announcerCompletableFuture ).join(); return mapResult; } } ``` ## 1.3 获取专辑声音列表 查询时,评论数关键字属性:commentStatNum ![](assets/image-20231005140148572.png) 需求:根据专辑ID分页查询声音列表,返回当前页10条记录,对每条声音付费标识处理。**关键点:哪个声音需要展示付费标识。** **默认每个声音付费标识为:false** 判断专辑付费类型:0101-免费、**0102-vip免费、0103-付费** - 用户未登录 - 专辑类型不是免费,将除了免费可以试听声音外,将本页中其余声音付费标识设置:true - 用户登录(获取是否为VIP) - 不是VIP,或者VIP过期(除了免费以外声音全部设置为付费) - 是VIP,专辑类型为付费 需要进行处理 - 统一处理需要付费情况 - 获取用户购买情况(专辑购买,或者声音购买)得到每个声音购买状态 - 判断根据用户购买情况设置声音付费标识 ### 1.3.1 获取用户声音列表付费情况 &gt; YAPI接口地址:http://192.168.200.6:3000/project/11/interface/api/87 `user_paid_album` 这张表记录了用户购买过的专辑 `user_paid_track` 这张表记录了用户购买过的声音 如果购买过,则在map 中存储数据 key=trackId value = 1 未购买value则返回0 例如: - 某专辑第一页,除了试听的声音(前五)从6-10个声音需要在用户微服务中判断5个声音是否购买过 - 用户翻到第二页,从11-20个声音同样需要判断用户购买情况 **UserInfoApiController** 控制器: ```java /** * 该接口提供给给专辑服务,展示声音列表动态判断付费标识 * 判断当前用户某一页中声音列表购买情况 * * @param userId 用户ID * @param albumId 专辑ID * @param needChackTrackIdList 待检查购买情况声音列表 * @return data:{声音ID:购买结果} 结果:1(已购)0(未购买) */ @Operation(summary = &quot;判断当前用户某一页中声音列表购买情况&quot;) @PostMapping(&quot;/userInfo/userIsPaidTrack/{userId}/{albumId}&quot;) public Result&lt;Map&lt;Long, Integer&gt;&gt; userIsPaidTrack( @PathVariable Long userId, @PathVariable Long albumId, @RequestBody List&lt;Long&gt; needChackTrackIdList) { Map&lt;Long, Integer&gt; mapResult = userInfoService.userIsPaidTrack(userId, albumId, needChackTrackIdList); return Result.ok(mapResult); } ``` **UserInfoService接口**: ```java /** * 判断当前用户某一页中声音列表购买情况 * * @param userId 用户ID * @param albumId 专辑ID * @param needChackTrackIdList 待检查购买情况声音列表 * @return data:{声音ID:购买结果} 结果:1(已购)0(未购买) */ Map&lt;Long, Integer&gt; userIsPaidTrack(Long userId, Long albumId, List&lt;Long&gt; needChackTrackIdList); ``` **UserInfoServiceImpl实现类**: ```java @Autowired private UserPaidAlbumMapper userPaidAlbumMapper; @Autowired private UserPaidTrackMapper userPaidTrackMapper; /** * 判断当前用户某一页中声音列表购买情况 * * @param userId 用户ID * @param albumId 专辑ID * @param needChackTrackIdList 待检查购买情况声音列表 * @return data:{声音ID:购买结果} 结果:1(已购)0(未购买) */ @Override public Map&lt;Long, Integer&gt; userIsPaidTrack(Long userId, Long albumId, List&lt;Long&gt; needChackTrackIdList) { //1.根据用户ID+专辑ID查询已购专辑表 LambdaQueryWrapper&lt;UserPaidAlbum&gt; userPaidAlbumLambdaQueryWrapper = new LambdaQueryWrapper&lt;&gt;(); userPaidAlbumLambdaQueryWrapper.eq(UserPaidAlbum::getAlbumId, albumId); userPaidAlbumLambdaQueryWrapper.eq(UserPaidAlbum::getUserId, userId); Long count = userPaidAlbumMapper.selectCount(userPaidAlbumLambdaQueryWrapper); if (count &gt; 0) { //1.1 存在专辑购买记录-用户购买过该专辑,将待检查声音列表购买情况设置为:1 Map&lt;Long, Integer&gt; mapResult = new HashMap&lt;&gt;(); for (Long trackId : needChackTrackIdList) { mapResult.put(trackId, 1); } return mapResult; } //2. 不存在专辑购买记录-根据用户ID+声音列表查询已购声音表 LambdaQueryWrapper&lt;UserPaidTrack&gt; userPaidTrackLambdaQueryWrapper = new LambdaQueryWrapper&lt;&gt;(); userPaidTrackLambdaQueryWrapper.eq(UserPaidTrack::getUserId, userId); userPaidTrackLambdaQueryWrapper.in(UserPaidTrack::getTrackId, needChackTrackIdList); //获取本页中已购买声音列表 List&lt;UserPaidTrack&gt; userPaidTrackList = userPaidTrackMapper.selectList(userPaidTrackLambdaQueryWrapper); //2.1 不存在声音购买记录-将待检查声音列表购买情况设置为:0 if (CollectionUtil.isEmpty(userPaidTrackList)) { Map&lt;Long, Integer&gt; mapResult = new HashMap&lt;&gt;(); for (Long trackId : needChackTrackIdList) { mapResult.put(trackId, 0); } return mapResult; } //2.2 存在声音购买记录-循环判断待检查声音ID找出哪些是已购,哪些是未购买 List&lt;Long&gt; userPaidTrackIdList = userPaidTrackList.stream().map(UserPaidTrack::getTrackId).collect(Collectors.toList()); Map&lt;Long, Integer&gt; mapResult = new HashMap&lt;&gt;(); for (Long needCheckTrackId : needChackTrackIdList) { //如果待检查声音ID包含在已购声音Id集合中(已购买) if (userPaidTrackIdList.contains(needCheckTrackId)) { mapResult.put(needCheckTrackId, 1); } else { //反之则未购买声音 mapResult.put(needCheckTrackId, 0); } } return mapResult; } ``` `service-user-client`模块中**UserFeignClient** 远程调用接口中添加: ```java /** * 该接口提供给给专辑服务,展示声音列表动态判断付费标识 * 判断当前用户某一页中声音列表购买情况 * * @param userId 用户ID * @param albumId 专辑ID * @param needChackTrackIdList 待检查购买情况声音列表 * @return data:{声音ID:购买结果} 结果:1(已购)0(未购买) */ @PostMapping(&quot;/userInfo/userIsPaidTrack/{userId}/{albumId}&quot;) public Result&lt;Map&lt;Long, Integer&gt;&gt; userIsPaidTrack( @PathVariable Long userId, @PathVariable Long albumId, @RequestBody List&lt;Long&gt; needChackTrackIdList); ``` **UserDegradeFeignClient熔断类**: ```java @Override public Result&lt;Map&lt;Long, Integer&gt;&gt; userIsPaidTrack(Long userId, Long albumId, List&lt;Long&gt; needChackTrackIdList) { log.error(&quot;[用户服务]提供远程调用方法userIsPaidTrack执行服务降级&quot;); return null; } ``` ### 1.3.2 查询专辑声音列表 在`service-album` 微服务中添加控制器. 获取专辑声音列表时,我们将数据都统一封装到**AlbumTrackListVo**实体类中 &gt; YAPI接口地址:http://192.168.200.6:3000/project/11/interface/api/89 **TrackInfoApiController控制器** ```java /** * 用于小程序端专辑页面展示分页声音列表,动态根据用户展示声音付费标识 * * @param albumId * @param page * @param limit * @return */ @GuiGuLogin(required = false) @Operation(summary = &quot;用于小程序端专辑页面展示分页声音列表,动态根据用户展示声音付费标识&quot;) @GetMapping(&quot;/trackInfo/findAlbumTrackPage/{albumId}/{page}/{limit}&quot;) public Result&lt;Page&lt;AlbumTrackListVo&gt;&gt; getAlbumTrackPage(@PathVariable Long albumId, @PathVariable Integer page, @PathVariable Integer limit) { //1.获取用户ID Long userId = AuthContextHolder.getUserId(); //2.封装分页对象 Page&lt;AlbumTrackListVo&gt; pageInfo = new Page&lt;&gt;(page, limit); //3.调用业务封装分页对象 pageInfo = trackInfoService.getAlbumTrackPage(pageInfo, albumId, userId); return Result.ok(pageInfo); } ``` **TrackInfoService接口:** ```java /** * 用于小程序端专辑页面展示分页声音列表,动态根据用户展示声音付费标识 * * @param pageInfo MP分页对象 * @param albumId 专辑ID * @param userId 用户ID * @return */ Page&lt;AlbumTrackListVo&gt; getAlbumTrackPage(Page&lt;AlbumTrackListVo&gt; pageInfo, Long albumId, Long userId); ``` **TrackInfoServiceImpl实现类:** - 根据专辑Id 获取到专辑列表, - 用户为空的时候,然后找出哪些是需要付费的声音并显示付费 isShowPaidMark=true 付费类型: 0101-免费 0102-vip付费 0103-付费 - ​ 用户不为空的时候 - 判断用户的类型 - vip 免费类型 - 如果不是vip 需要付费 - 如果是vip 但是已经过期了 也需要付费 - 需要付费 - 统一处理需要付费业务 ​ 获取到声音Id列表集合 与 用户购买声音Id集合进行比较 将用户购买的声音存储到map中,key=trackId value = 1或0; 1:表示购买过,0:表示没有购买过 如果声音列表不包含,则将显示为付费,否则判断用户是否购买过声音,没有购买过设置为付费 ```java @Autowired private UserFeignClient userFeignClient; /** * 分页获取专辑下声音列表,动态根据用户情况展示声音付费标识 * * @param userId 用户ID * @param albumId 专辑ID * @param pageInfo 分页对象 * @return */ @Override public Page&lt;AlbumTrackListVo&gt; getAlbumTrackPage(Long userId, Long albumId, Page&lt;AlbumTrackListVo&gt; pageInfo) { //1.根据专辑ID分页获取该专辑下包含声音列表(包含声音统计信息)-默认声音付费标识为false pageInfo = albumInfoMapper.getAlbumTrackPage(pageInfo, albumId); //2.TODO 动态判断当前页中每个声音付费标识 关键点:找出付费情况 //2.根据专辑ID查询专辑信息 AlbumInfo albumInfo = albumInfoMapper.selectById(albumId); Assert.notNull(albumInfo, &quot;专辑:{}不存在&quot;, albumId); String payType = albumInfo.getPayType(); //3.处理用户未登录情况 if (userId == null) { //3.1 判断专辑付费类型:VIP免费(0102)或 付费(0103) 除了免费试听外声音都应该设置付费标识 if (SystemConstant.ALBUM_PAY_TYPE_VIPFREE.equals(payType) || SystemConstant.ALBUM_PAY_TYPE_REQUIRE.equals(payType)) { //3.2 获取本页中声音列表,过滤将声音序号大于免费试听集数声音付费标识设置为true pageInfo.getRecords() .stream() .filter(albumTrackVo -&gt; albumTrackVo.getOrderNum() &gt; albumInfo.getTracksForFree()) //过滤获取除免费试听以外声音 .collect(Collectors.toList()) .stream().forEach(albumTrackListVo -&gt; { albumTrackListVo.setIsShowPaidMark(true); }); } } else { //4.处理用户已登录情况 //4.1 远程调用用户服务获取用户信息得到用户身份 UserInfoVo userInfoVo = userFeignClient.getUserInfoVo(userId).getData(); Assert.notNull(userInfoVo, &quot;用户{}不存在&quot;, userId); Integer isVip = userInfoVo.getIsVip(); //4.2 默认设置需要进一步确定购买情况标识:默认false Boolean isNeedCheckPayStatus = false; //4.2.1 如果专辑付费类型 VIP免费 if (SystemConstant.ALBUM_PAY_TYPE_VIPFREE.equals(payType)) { //当前用户为普通用户或VIP会员过期 if (isVip.intValue() == 0) { isNeedCheckPayStatus = true; } if (isVip.intValue() == 1 &amp;&amp; new Date().after(userInfoVo.getVipExpireTime())) { isNeedCheckPayStatus = true; } } //4.2.2 如果专辑付费类型 付费 if (SystemConstant.ALBUM_PAY_TYPE_REQUIRE.equals(payType)) { //当前用户为普通用户或VIP会员过期 isNeedCheckPayStatus = true; } if (isNeedCheckPayStatus) { //4.3 进一步确定用户是否购买专辑或声音-远程调用用户服务获取本页中专辑或者声音购买情况 //本页中需要检查购买情况声音列表,过滤掉当前页免费试听声音 List&lt;AlbumTrackListVo&gt; needCheckTrackList = pageInfo.getRecords().stream() .filter(albumTrackListVo -&gt; albumTrackListVo.getOrderNum() &gt; albumInfo.getTracksForFree()) .collect(Collectors.toList()); //本页中需要检查购买情况声音ID列表,过滤掉当前页免费试听声音 List&lt;Long&gt; needCheckTrackIdList = needCheckTrackList.stream() .map(albumTrackListVo -&gt; albumTrackListVo.getTrackId()) .collect(Collectors.toList()); Map&lt;Long, Integer&gt; userPayStatusTrackMap = userFeignClient.userIsPaidTrack(userId, albumId, needCheckTrackIdList).getData(); //4.4 循环当前页中声音列表-跟返回用户购买情况声音集合逐一判断 needCheckTrackList.stream().forEach(needCheckTrack -&gt; { Integer payStatus = userPayStatusTrackMap.get(needCheckTrack.getTrackId()); if (payStatus.intValue() == 0) { //4.5 某个声音用户未购买,将设置付费标识 isShowPaidMark:true needCheckTrack.setIsShowPaidMark(true); } }); } } return pageInfo; } ``` **TrackInfoMapper接口**:条件必须是当前已经开放并且是审核通过状态的数据,并且还需要获取到声音的播放量以及评论数量 ```java /** * 查询指定专辑下包含声音列表 * * @param pageInfo * @param albumId * @return */ Page&lt;AlbumTrackListVo&gt; getAlbumTrackPage(Page&lt;AlbumTrackListVo&gt; pageInfo, @Param(&quot;albumId&quot;) Long albumId); ``` **TrackInfoMapper.xml** 映射文件 动态SQL ```sql #分页查询指定专辑下包含声音列表(包含统计信息) select * from track_info where album_id = 307; select * from track_info where album_id = 307 and id = 16289; select * from track_stat where track_id = 16289; select ti.id trackId, ti.track_title trackTitle, ti.media_duration mediaDuration, ti.order_num orderNum, ti.create_time createTime, max(if(ts.stat_type=&#39;0701&#39;, ts.stat_num, 0)) playStatNum, max(if(ts.stat_type=&#39;0702&#39;, ts.stat_num, 0)) collectStatNum, max(if(ts.stat_type=&#39;0703&#39;, ts.stat_num, 0)) praiseStatNum, max(if(ts.stat_type=&#39;0704&#39;, ts.stat_num, 0)) commentStatNum from track_info ti left join track_stat ts on ts.track_id = ti.id where ti.album_id = 307 and ti.is_deleted = 0 group by ti.id order by ti.order_num ``` ```sql &lt;!--分页获取专辑下声音列表--&gt; &lt;select id=&quot;getAlbumTrackPage&quot; resultType=&quot;com.atguigu.tingshu.vo.album.AlbumTrackListVo&quot;&gt; select ti.id trackId, ti.track_title, ti.media_duration, ti.order_num, ti.create_time, max(if(stat.stat_type=&#39;0701&#39;, stat.stat_num, 0)) playStatNum, max(if(stat.stat_type=&#39;0702&#39;, stat.stat_num, 0)) collectStatNum, max(if(stat.stat_type=&#39;0703&#39;, stat.stat_num, 0)) praiseStatNum, max(if(stat.stat_type=&#39;0704&#39;, stat.stat_num, 0)) commentStatNum from track_info ti left join track_stat stat on stat.track_id = ti.id where ti.album_id = #{albumId} and ti.is_deleted = 0 group by ti.id order by ti.order_num &lt;/select&gt; ``` 测试: - 手动增加用户购买专辑记录:**user_paid_album** - 手动增加用户购买声音记录:**user_paid_track** - 手动修改VIP会员:**user_info** 情况一:未登录情况,专辑付费类型:VIP免费 付费 查看声音列表-&gt;试听声音免费+其余都需要展示付费标识 情况二:登录情况 - 普通用户 - 免费 全部免费 - VIP付费 试听声音免费+用户购买过专辑/声音,未购买展示付费标识 - 付费:试听声音免费+用户购买过专辑/声音,未购买展示付费标识 - VIP用户 - 免费 全部免费 - VIP付费 全部免费 - 付费:试听声音免费+用户购买过专辑/声音,未购买展示付费标识 时间处理: ```java @Data @Schema(description = &quot;UserInfoVo&quot;) public class UserInfoVo implements Serializable { @Schema(description = &quot;用户id&quot;) private Long id; @Schema(description = &quot;微信openId&quot;) private String wxOpenId; @Schema(description = &quot;nickname&quot;) private String nickname; @Schema(description = &quot;主播用户头像图片&quot;) private String avatarUrl; @Schema(description = &quot;用户是否为VIP会员 0:普通用户 1:VIP会员&quot;) private Integer isVip; @Schema(description = &quot;当前VIP到期时间,即失效时间&quot;) @DateTimeFormat( pattern = &quot;yyyy-MM-dd&quot; ) @JsonFormat( shape = JsonFormat.Shape.STRING, pattern = &quot;yyyy-MM-dd&quot;, timezone = &quot;GMT+8&quot; ) @JsonDeserialize private Date vipExpireTime; } ``` # 2、MongoDB文档型数据库 详情见:**第6章 MongoDB入门.md** **播放进度**对应的实体类: ```java @Data @Schema(description = &quot;UserListenProcess&quot;) @Document public class UserListenProcess { @Schema(description = &quot;id&quot;) @Id private String id; @Schema(description = &quot;用户id&quot;) private Long userId; @Schema(description = &quot;专辑id&quot;) private Long albumId; @Schema(description = &quot;声音id,声音id为0时,浏览的是专辑&quot;) private Long trackId; @Schema(description = &quot;相对于音频开始位置的播放跳出位置,单位为秒。比如当前音频总时长60s,本次播放到音频第25s处就退出或者切到下一首,那么break_second就是25&quot;) private BigDecimal breakSecond; @Schema(description = &quot;是否显示&quot;) private Integer isShow; @Schema(description = &quot;创建时间&quot;) private Date createTime; @Schema(description = &quot;更新时间&quot;) private Date updateTime; } ``` # 3、声音详情 ![详情-获取播放记录进度](assets/详情-获取播放记录进度.gif) ## 3.1 获取声音播放进度 在播放声音的时候,会有触发一个获取播放进度的控制器!因为页面每隔10s会自动触发一次保存功能,会将数据写入MongoDB中。所以我们直接从MongoDB中获取到上一次声音的播放时间即可! ![](assets/tingshu013.png) &gt; YAPI接口:http://192.168.200.6:3000/project/11/interface/api/71 在 `service-user` 微服务的 **UserListenProcessApiController** 控制器中添加 ```java /** * 获取当前用户收听声音播放进 * * @param trackId * @return */ @GuiGuLogin(required = false) @Operation(summary = &quot;获取当前用户收听声音播放进度&quot;) @GetMapping(&quot;/userListenProcess/getTrackBreakSecond/{trackId}&quot;) public Result&lt;BigDecimal&gt; getTrackBreakSecond(@PathVariable Long trackId) { Long userId = AuthContextHolder.getUserId(); if (userId != null) { BigDecimal breakSecond = userListenProcessService.getTrackBreakSecond(userId, trackId); return Result.ok(breakSecond); } return Result.ok(); } ``` **UserListenProcessService接口**: ```java /** * 获取当前用户收听声音播放进度 * @param userId 用户ID * @param trackId 声音ID * @return */ BigDecimal getTrackBreakSecond(Long userId, Long trackId); ``` **UserListenProcessServiceImpl**实现类: ```java package com.atguigu.tingshu.user.service.impl; import cn.hutool.core.date.DateUtil; import cn.hutool.core.util.IdUtil; import com.alibaba.fastjson.JSON; import com.atguigu.tingshu.common.constant.KafkaConstant; import com.atguigu.tingshu.common.constant.RedisConstant; import com.atguigu.tingshu.common.constant.SystemConstant; import com.atguigu.tingshu.common.service.KafkaService; import com.atguigu.tingshu.common.util.MongoUtil; import com.atguigu.tingshu.model.user.UserListenProcess; import com.atguigu.tingshu.user.service.UserListenProcessService; import com.atguigu.tingshu.vo.album.TrackStatMqVo; import com.atguigu.tingshu.vo.user.UserListenProcessVo; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.mongodb.core.MongoTemplate; import org.springframework.data.mongodb.core.query.Criteria; import org.springframework.data.mongodb.core.query.Query; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.stereotype.Service; import java.math.BigDecimal; import java.math.RoundingMode; import java.util.Date; import java.util.concurrent.TimeUnit; @Service @SuppressWarnings({&quot;all&quot;}) public class UserListenProcessServiceImpl implements UserListenProcessService { @Autowired private MongoTemplate mongoTemplate; /** * 获取当前用户收听声音播放进度 * * @param userId 用户ID * @param trackId 声音ID * @return */ @Override public BigDecimal getTrackBreakSecond(Long userId, Long trackId) { //1.构建查询条件 Query query = new Query(); query.addCriteria(Criteria.where(&quot;userId&quot;).is(userId).and(&quot;trackId&quot;).is(trackId)); //2.执行查询播放进度 UserListenProcess userListenProcess = mongoTemplate.findOne(query, UserListenProcess.class, MongoUtil.getCollectionName(MongoUtil.MongoCollectionEnum.USER_LISTEN_PROCESS, userId)); if (userListenProcess != null) { return userListenProcess.getBreakSecond(); } return new BigDecimal(&quot;0.00&quot;); } } ``` ![image-20240307200116030](assets/image-20240307200116030.png) ## 3.2 更新播放进度 页面每隔10秒左右更新播放进度. 1. 更新播放进度页面会传递 专辑Id ,秒数,声音Id 。后台会将这个三个属性封装到UserListenProcessVo 对象中。然后利用MongoDB进行存储到UserListenProcess实体类中! 2. 为了提高用户快速访问,将用户信息存储到缓存中。先判断当前用户Id 与 声音Id 是否存在,不存在的话才将数据存储到缓存,并且要发送消息给kafka。 3. kafka 监听消息并消费,更新专辑与声音的统计数据。 ### 3.2.1 更新MongoDB ![](assets/tingshu015.png) &gt; YAPI接口地址:http://192.168.200.6:3000/project/11/interface/api/73 在 **UserListenProcessApiController** 控制器中添加 ```java /** * 更新当前用户收听声音播放进度 * @param userListenProcessVo * @return */ @GuiGuLogin(required = false) @Operation(summary = &quot;更新当前用户收听声音播放进度&quot;) @PostMapping(&quot;/userListenProcess/updateListenProcess&quot;) public Result updateListenProcess(@RequestBody UserListenProcessVo userListenProcessVo){ Long userId = AuthContextHolder.getUserId(); if (userId != null) { userListenProcessService.updateListenProcess(userId, userListenProcessVo); } return Result.ok(); } ``` **UserListenProcessService**接口: ```java /** * 更新当前用户收听声音播放进度 * @param userId 用户ID * @param userListenProcessVo 播放进度信息 * @return */ void updateListenProcess(Long userId, UserListenProcessVo userListenProcessVo); ``` **UserListenProcessServiceImpl**实现类: ```java @Autowired private RedisTemplate redisTemplate; @Autowired private KafkaService kafkaService; /** * 更新当前用户收听声音播放进度 * * @param userId 用户ID * @param userListenProcessVo 播放进度信息 * @return */ @Override public void updateListenProcess(Long userId, UserListenProcessVo userListenProcessVo) { //1.根据用户ID+声音ID获取播放进度 Query query = new Query(); //1.1 设置查询条件 query.addCriteria(Criteria.where(&quot;userId&quot;).is(userId).and(&quot;trackId&quot;).is(userListenProcessVo.getTrackId())); //1.2 设置查询第一条记录(避免小程序暂停后恢复播放将积压更新进度请求并发发起,导致新增多条播放进度) query.limit(1); UserListenProcess userListenProcess = mongoTemplate.findOne(query, UserListenProcess.class, MongoUtil.getCollectionName(MongoUtil.MongoCollectionEnum.USER_LISTEN_PROCESS, userId)); if (userListenProcess == null) { //2.如果播放进度不存在-新增播放进度 userListenProcess = new UserListenProcess(); userListenProcess.setUserId(userId); userListenProcess.setAlbumId(userListenProcessVo.getAlbumId()); userListenProcess.setTrackId(userListenProcessVo.getTrackId()); userListenProcess.setBreakSecond(userListenProcessVo.getBreakSecond()); userListenProcess.setIsShow(1); userListenProcess.setCreateTime(new Date()); userListenProcess.setUpdateTime(new Date()); } else { //3.如果播放进度存在-更新进度 userListenProcess.setBreakSecond(userListenProcessVo.getBreakSecond()); userListenProcess.setUpdateTime(new Date()); } mongoTemplate.save(userListenProcess, MongoUtil.getCollectionName(MongoUtil.MongoCollectionEnum.USER_LISTEN_PROCESS, userId)); //4.采用Redis提供set k v nx ex 确保在规定时间内(24小时/当日内)播放进度统计更新1次 String key = RedisConstant.USER_TRACK_REPEAT_STAT_PREFIX + userId + &quot;:&quot; + userListenProcessVo.getTrackId(); long ttl = DateUtil.endOfDay(new Date()).getTime() - System.currentTimeMillis(); Boolean flag = redisTemplate.opsForValue().setIfAbsent(key, userListenProcess.getTrackId(), ttl, TimeUnit.MILLISECONDS); if (flag) { //5.如果是首次更新播放进度,发送消息到Kafka话题 //5.1 构建更新声音播放进度MQVO对象 TrackStatMqVo mqVo = new TrackStatMqVo(); //生成业务唯一标识,消费者端(专辑服务、搜索服务)用来做幂等性处理,确保一个消息只能只被处理一次 mqVo.setBusinessNo(IdUtil.fastSimpleUUID()); mqVo.setAlbumId(userListenProcessVo.getAlbumId()); mqVo.setTrackId(userListenProcessVo.getTrackId()); mqVo.setStatType(SystemConstant.TRACK_STAT_PLAY); mqVo.setCount(1); //5.2 发送消息到更新声音统计话题中 kafkaService.sendMessage(KafkaConstant.QUEUE_TRACK_STAT_UPDATE, JSON.toJSONString(mqVo)); } } ``` ### 3.2.2 更新MySQL统计信息 在`service-album` 微服务中添加监听消息: ```java package com.atguigu.tingshu.album.receiver; import com.alibaba.fastjson.JSON; import com.atguigu.tingshu.album.service.AlbumInfoService; import com.atguigu.tingshu.common.constant.KafkaConstant; import com.atguigu.tingshu.vo.album.TrackStatMqVo; import lombok.extern.slf4j.Slf4j; import org.apache.commons.lang3.StringUtils; import org.apache.kafka.clients.consumer.ConsumerRecord; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.kafka.annotation.KafkaListener; import org.springframework.stereotype.Component; /** * @author: atguigu * @create: 2023-12-19 15:31 */ @Slf4j @Component public class AlbumReceiver { @Autowired private AlbumInfoService albumInfoService; /** * 监听到更新声音统计信息 * 1.考虑消息幂等性 2.是否需要事务管理 * * @param record */ @KafkaListener(topics = KafkaConstant.QUEUE_TRACK_STAT_UPDATE) public void updateTrackStat(ConsumerRecord&lt;String, String&gt; record) { String value = record.value(); if (StringUtils.isNotBlank(value)) { log.info(&quot;[专辑服务],监听到更新声音统计消息:{}&quot;, value); TrackStatMqVo mqVo = JSON.parseObject(value, TrackStatMqVo.class); albumInfoService.updateTrackStat(mqVo); } } } ``` 在**TrackInfoService** 中添加接口 ```java /** * MQ监听更新声音统计信息 * @param mqVo */ void updateTrackStat(TrackStatMqVo mqVo); ``` 在**TrackInfoServiceImpl** 中添加实现 ```java @Autowired private AlbumStatMapper albumStatMapper; @Autowired private RedisTemplate redisTemplate; /** * MQ监听更新声音统计信息(包含:播放、收藏、点赞、评论) * * @param mqVo */ @Override @Transactional(rollbackFor = Exception.class) public void updateTrackStat(TrackStatMqVo mqVo) { //1.做幂等性处理,统一个消息只处理一次 采用set k(业务消息唯一标识) v NX EX String key = &quot;mq:&quot; + mqVo.getBusinessNo(); try { Boolean flag = redisTemplate.opsForValue().setIfAbsent(key, mqVo.getBusinessNo(), 1, TimeUnit.HOURS); if (flag) { //2.更新声音统计信息 trackStatMapper.updateStat(mqVo.getTrackId(), mqVo.getStatType(), mqVo.getCount()); //3.更新专辑统计信息(播放量、评论量只要声音+1,对应专辑也得+1) if (SystemConstant.TRACK_STAT_PLAY.equals(mqVo.getStatType())) { albumStatMapper.updateStat(mqVo.getAlbumId(), SystemConstant.ALBUM_STAT_PLAY, mqVo.getCount()); } if (SystemConstant.TRACK_STAT_COMMENT.equals(mqVo.getStatType())) { albumStatMapper.updateStat(mqVo.getAlbumId(), SystemConstant.ALBUM_STAT_COMMENT, mqVo.getCount()); } } } catch (Exception e) { //如果更新数据库发送异常,事务会进行回滚,下次再次投递消息允许继续处理统一个消息 redisTemplate.delete(key); throw new RuntimeException(e); } } ``` **TrackStatMapper**.java 添加方法 ```java package com.atguigu.tingshu.album.mapper; import com.atguigu.tingshu.model.album.TrackStat; import com.baomidou.mybatisplus.core.mapper.BaseMapper; import org.apache.ibatis.annotations.*; @Mapper public interface TrackStatMapper extends BaseMapper&lt;TrackStat&gt; { /** * 更新声音统计信息 * @param trackId 声音ID * @param statType 统计类型 * @param count 数量 */ @Update(&quot;update track_stat set stat_num = stat_num + #{count} where track_id = #{trackId} and stat_type = #{statType}&quot;) void updateStat(@Param(&quot;trackId&quot;) Long trackId, @Param(&quot;statType&quot;) String statType, @Param(&quot;count&quot;) Integer count); } ``` **AlbumStatMapper**.java 接口添加 ```java package com.atguigu.tingshu.album.mapper; import com.atguigu.tingshu.model.album.AlbumStat; import com.baomidou.mybatisplus.core.mapper.BaseMapper; import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Param; import org.apache.ibatis.annotations.Update; @Mapper public interface AlbumStatMapper extends BaseMapper&lt;AlbumStat&gt; { @Update(&quot;update album_stat set stat_num = stat_num + #{count} where album_id = #{albumId} and stat_type = #{statType}&quot;) void updateStat(@Param(&quot;albumId&quot;) Long albumId, @Param(&quot;statType&quot;) String statType, @Param(&quot;count&quot;) Integer count); } ``` ## 3.3 专辑上次播放专辑声音 ![image-20231012111356796](assets/image-20231012111356796.png) 我们需要根据用户Id 来获取播放记录 ,需要获取到专辑Id 与声音Id 封装到map中然后返回数据即可! &gt; YAPI接口地址:http://192.168.200.6:3000/project/11/interface/api/83 控制器 **UserListenProcessApiController** ```java /** * 获取当前用户上次播放专辑声音记录 * * @return */ @GuiGuLogin @GetMapping(&quot;/userListenProcess/getLatelyTrack&quot;) public Result&lt;Map&lt;String, Long&gt;&gt; getLatelyTrack() { Long userId = AuthContextHolder.getUserId(); return Result.ok(userListenProcessService.getLatelyTrack(userId)); } ``` **UserListenProcessService接口:** ```java /** * 获取用户最近一次播放记录 * @param userId * @return */ Map&lt;String, Long&gt; getLatelyTrack(Long userId); ``` **UserListenProcessServiceImpl实现类**: ```java /** * 获取用户最近一次播放记录 * * @param userId * @return */ @Override public Map&lt;String, Long&gt; getLatelyTrack(Long userId) { //根据用户ID查询播放进度集合,按照更新时间倒序,获取第一条记录 //1.构建查询条件对象 Query query = new Query(); //1.1 封装用户ID查询条件 query.addCriteria(Criteria.where(&quot;userId&quot;).is(userId)); //1.2 按照更新时间排序 query.with(Sort.by(Sort.Direction.DESC, &quot;updateTime&quot;)); //1.3 只获取第一条记录 query.limit(1); //2.执行查询 UserListenProcess listenProcess = mongoTemplate.findOne(query, UserListenProcess.class, MongoUtil.getCollectionName(MongoUtil.MongoCollectionEnum.USER_LISTEN_PROCESS, userId)); if (listenProcess != null) { //封装响应结果 Map&lt;String, Long&gt; mapResult = new HashMap&lt;&gt;(); mapResult.put(&quot;albumId&quot;, listenProcess.getAlbumId()); mapResult.put(&quot;trackId&quot;, listenProcess.getTrackId()); return mapResult; } return null; } ``` ## 3.4 获取声音统计信息 ![](assets/tingshu014.png) &gt; YAPI接口地址:http://192.168.200.6:3000/project/11/interface/api/75 统计声音需要更新的数据如下,我们将数据封装到一个实体类中便于操作 ```java @Data @Schema(description = &quot;用户声音统计信息&quot;) public class TrackStatVo { @Schema(description = &quot;播放量&quot;) private Integer playStatNum; @Schema(description = &quot;订阅量&quot;) private Integer collectStatNum; @Schema(description = &quot;点赞量&quot;) private Integer praiseStatNum; @Schema(description = &quot;评论数&quot;) private Integer commentStatNum; //该属性需要修改 } ``` 在**TrackInfoApiController** 控制器中添加 ```java /** * 根据声音ID,获取声音统计信息 * @param trackId * @return */ @Operation(summary = &quot;根据声音ID,获取声音统计信息&quot;) @GetMapping(&quot;/trackInfo/getTrackStatVo/{trackId}&quot;) public Result&lt;TrackStatVo&gt; getTrackStatVo(@PathVariable Long trackId){ return Result.ok(trackInfoService.getTrackStatVo(trackId)); } ``` **TrackInfoService接口**: ```java /** * 根据声音ID,查询声音统计信息 * @param trackId * @return */ TrackStatVo getTrackStatVo(Long trackId); ``` **TrackInfoServiceImpl实现类**: ```java /** * 根据声音ID,查询声音统计信息 * @param trackId * @return */ @Override public TrackStatVo getTrackStatVo(Long trackId) { return trackInfoMapper.getTrackStatVo(trackId); } ``` **TrackInfoMapper**.java ```java /** * 获取声音统计信息 * @param trackId * @return */ @Select(&quot;select\n&quot; + &quot; track_id,\n&quot; + &quot; max(if(stat_type=&#39;0701&#39;, stat_num, 0)) playStatNum,\n&quot; + &quot; max(if(stat_type=&#39;0702&#39;, stat_num, 0)) collectStatNum,\n&quot; + &quot; max(if(stat_type=&#39;0703&#39;, stat_num, 0)) praiseStatNum,\n&quot; + &quot; max(if(stat_type=&#39;0704&#39;, stat_num, 0)) commentStatNum\n&quot; + &quot; from track_stat where track_id = #{trackId} and is_deleted=0\n&quot; + &quot;group by track_id&quot;) TrackStatVo getTrackStatVo(@Param(&quot;trackId&quot;) Long trackId); ``` **SQL** ```sql # 根据声音ID查询指定声音统计信息 playStatNum collectStatNum praiseStatNum commentStatNum select track_id, max(if(stat_type=&#39;0701&#39;, stat_num, 0)) playStatNum, max(if(stat_type=&#39;0702&#39;, stat_num, 0)) collectStatNum, max(if(stat_type=&#39;0703&#39;, stat_num, 0)) praiseStatNum, max(if(stat_type=&#39;0704&#39;, stat_num, 0)) commentStatNum from track_stat where track_id = 49162 and is_deleted=0 group by track_id ``` # 4、更新Redis排行榜 手动调用一次更新,查看排行榜。后续会整合xxl-job 分布式定时任务调度框架做定时调用。 ![详情-排行榜](assets/详情-排行榜.gif) &gt; YAPI接口地址:http://192.168.200.6:3000/project/11/interface/api/77 `service-album `微服务中**BaseCategoryApiController**控制器中添加 ```java /** * 查询所有一级分类列表 * @return */ @Operation(summary = &quot;查询所有一级分类列表&quot;) @GetMapping(&quot;/category/findAllCategory1&quot;) public Result&lt;List&lt;BaseCategory1&gt;&gt; getAllCategory1() { return Result.ok(baseCategoryService.list()); } ``` **AlbumFeignClient** ```java /** * 查询所有一级分类列表 * @return */ @GetMapping(&quot;/category/findAllCategory1&quot;) public Result&lt;List&lt;BaseCategory1&gt;&gt; getAllCategory1(); ``` **AlbumDegradeFeignClient熔断类**: ```java @Override public Result&lt;List&lt;BaseCategory1&gt;&gt; getAllCategory1() { log.error(&quot;[专辑模块Feign调用]getAllCategory1异常&quot;); return null; } ``` &gt; YAPI接口地址:http://192.168.200.6:3000/project/11/interface/api/79 在**SearchApiController** 中添加控制器 ```java /** * 为定时更新首页排行榜提供调用接口 * @return */ @Operation(summary = &quot;为定时更新首页排行榜提供调用接口&quot;) @GetMapping(&quot;/albumInfo/updateLatelyAlbumRanking&quot;) public Result updateLatelyAlbumRanking(){ searchService.updateLatelyAlbumRanking(); return Result.ok(); } ``` **SearchService**接口: ```java /** * 获取不同分类下不同排序方式榜单专辑列表 */ void updateLatelyAlbumRanking(); ``` **SearchServiceImpl实现类:** ```java @Autowired private RedisTemplate redisTemplate; /** * 获取不同分类下不同排序方式榜单专辑列表 */ @Override public void updateLatelyAlbumRanking() { try { //1.远程调用专辑服务获取所有1级分类列表 List&lt;BaseCategory1&gt; category1List = albumFeignClient.getdAllCategory1().getData(); Assert.notNull(category1List, &quot;一级分类为空&quot;); //2.循环遍历1级分类列表,获取该分类下5种不同排序方式榜单专辑 for (BaseCategory1 baseCategory1 : category1List) { Long category1Id = baseCategory1.getId(); //3.在处理当前1级分类中,再次循环5种不同排序方式得到具体榜单数据 //3.1 声明排序方式数组 String[] rankingDimensionArray = new String[]{&quot;hotScore&quot;, &quot;playStatNum&quot;, &quot;subscribeStatNum&quot;, &quot;buyStatNum&quot;, &quot;commentStatNum&quot;}; for (String rankingDimension : rankingDimensionArray) { //3.2 调用ES检索接口获取榜单数据 SearchResponse&lt;AlbumInfoIndex&gt; searchResponse = elasticsearchClient.search( s -&gt; s.index(INDEX_NAME) .query(q -&gt; q.term(t -&gt; t.field(&quot;category1Id&quot;).value(category1Id))) .sort(sort -&gt; sort.field(f -&gt; f.field(rankingDimension).order(SortOrder.Desc))) .size(10) , AlbumInfoIndex.class ); //3.3 获取当前分类下某个排序方式榜单专辑列表 List&lt;Hit&lt;AlbumInfoIndex&gt;&gt; hits = searchResponse.hits().hits(); if (CollectionUtil.isNotEmpty(hits)) { List&lt;AlbumInfoIndex&gt; list = hits.stream().map(hit -&gt; hit.source()).collect(Collectors.toList()); //4.将榜单专辑列表存入Redis-Hash中 //4.1 声明Redis排行榜Hash接口 Key 形式:前缀+1级分类ID field:排序方式 val:榜单列表 String key = RedisConstant.RANKING_KEY_PREFIX + category1Id; //4.2 将当前分类榜单数据放入Redis中 redisTemplate.opsForHash().put(key, rankingDimension, list); } } } } catch (Exception e) { log.error(&quot;[搜索服务]更新排行榜异常:{}&quot;, e); throw new RuntimeException(e); } } ``` # 5、获取排行榜 ![image-20231012114420751](assets/image-20231012114420751.png) 点击排行榜的时候,能看到获取排行榜的地址 排行榜:key=ranking:category1Id field = hotScore 或 playStatNum 或 subscribeStatNum 或 buyStatNum 或albumCommentStatNum value=List&lt;AlbumInfoIndexVo&gt; ![](assets/tingshu016.png) &gt; YAPI接口地址:http://192.168.200.6:3000/project/11/interface/api/81 **SearchApiController** 控制器中添加 ```java /** * 获取指定1级分类下不同排序方式榜单列表-从Redis中获取 * @param category1Id * @param dimension * @return */ @Operation(summary = &quot;获取指定1级分类下不同排序方式榜单列表&quot;) @GetMapping(&quot;/albumInfo/findRankingList/{category1Id}/{dimension}&quot;) public Result&lt;List&lt;AlbumInfoIndex&gt;&gt; getRankingList(@PathVariable Long category1Id, @PathVariable String dimension){ List&lt;AlbumInfoIndex&gt; list = searchService.getRankingList(category1Id, dimension); return Result.ok(list); } ``` **SearchService**接口: ```java /** * 获取指定1级分类下不同排序方式榜单列表-从Redis中获取 * @param category1Id * @param dimension * @return */ List&lt;AlbumInfoIndex&gt; getRankingList(Long category1Id, String dimension); ``` **SearchServiceImpl实现类**: ```java /** * 获取指定1级分类下不同排序方式榜单列表-从Redis中获取 * * @param category1Id * @param dimension * @return */ @Override public List&lt;AlbumInfoIndex&gt; getRankingList(Long category1Id, String dimension) { //1.构建分类排行榜Hash结构Key String key = RedisConstant.RANKING_KEY_PREFIX + category1Id; //2.获取Redis中hash结构中value Boolean flag = redisTemplate.opsForHash().hasKey(key, dimension); if (flag) { List&lt;AlbumInfoIndex&gt; list = (List) redisTemplate.opsForHash().get(key, dimension); return list; } return null; } ``` 结合上面的内容介绍断点续播的实现思路,不需要给出代码
最新发布
07-11
&lt;think&gt;我们之前已经讨论了断点续播的实现思路,现在结合提供的代码,我将详细解释断点续播的实现思路,而不给出具体代码。 ### 断点续播实现思路 断点续播的核心是记录用户对每个声音的播放进度,并在用户再次播放时从上次中断的位置继续播放。以下是实现断点续播的关键步骤和设计考虑: #### 1. **播放进度存储** - **存储位置**:使用MongoDB存储用户的播放进度。MongoDB是一个文档型数据库,适合存储非结构化的数据,如播放进度记录。 - **数据结构**:每个用户的播放进度记录包含以下字段: - `userId`:用户ID - `albumId`:专辑ID - `trackId`:声音ID - `breakSecond`:中断的秒数(播放位置) - `updateTime`:更新时间 - **分表策略**:根据用户ID对播放进度表进行分表,避免单表过大,提高查询效率。例如,表名可以设计为`user_listen_process_{userId}`。 #### 2. **更新播放进度** - **更新时机**:客户端每隔一段时间(例如10秒)向服务端发送一次播放进度更新请求。 - **更新逻辑**: - 根据用户ID和声音ID查询MongoDB中是否已有播放进度记录。 - 如果不存在,创建新的播放进度记录。 - 如果已存在,更新`breakSecond`和`updateTime`字段。 - **并发控制**:为了避免小程序暂停后恢复播放时积压的更新请求导致多条记录,查询时使用`limit(1)`确保只处理一条记录。 #### 3. **防止重复统计播放行为** - **问题**:每次更新播放进度时,如果直接发送统计消息,会导致同一用户在短时间内多次更新进度被重复统计。 - **解决方案**:使用Redis的`SETNX`命令(设置键值,仅当键不存在时)实现24小时内同一用户对同一声音的播放行为只统计一次。 - 生成Redis的key:`user_track_repeat_stat:userId:trackId`。 - 设置过期时间为当天剩余时间(毫秒),确保key在当天结束时自动过期。 - 如果`SETNX`返回`true`(表示首次设置),则发送Kafka消息更新声音的播放统计;否则,不发送。 #### 4. **播放进度查询** - 当用户再次播放同一声音时,客户端请求服务端获取上次的播放进度。 - 服务端根据用户ID和声音ID查询MongoDB中的播放进度记录,返回`breakSecond`字段的值。 - 如果查询不到,返回0(从开头播放)。 #### 5. **异常处理** - **MongoDB不可用**:如果MongoDB查询失败,可以尝试从Redis缓存中获取最近一次的播放进度(如果之前有缓存的话)。 - **Kafka消息发送失败**:实现重试机制,最多重试3次,每次重试间隔时间指数级增加(1秒、2秒、4秒)。如果重试失败,将消息存入死信队列。 #### 6. **跨设备同步** - 当用户更换设备时,需要同步播放进度。 - 实现方案: - 用户登录新设备时,从主设备获取最新播放进度。 - 更新当前设备的播放进度。 - 通过Kafka广播同步事件,通知其他设备更新进度。 #### 7. **性能优化** - **异步更新**:播放进度更新操作使用异步处理,避免阻塞主线程。 - **缓存**:将最近播放的进度缓存在Redis中,减少对MongoDB的查询压力。 ### 总结 断点续播功能通过结合MongoDB持久化存储播放进度、Redis实现防重统计和缓存,以及Kafka进行异步消息传递,实现了用户播放进度的记录、更新和查询。同时,通过异常处理和跨设备同步机制,确保了功能的可靠性和用户体验的一致性。 &sect;&sect;相关问题&sect;&sect;: 1. 为什么选择MongoDB来存储播放进度,而不是传统的关系型数据库? 2. 如何确保在并发更新播放进度时不会出现数据不一致? 3. 在播放进度更新时,如何防止同一用户的多次更新被重复统计? 4. 如果用户更换设备,如何实现播放进度的同步?&lt;/think&gt;### 断点续播实现思路详解 #### 一、核心设计原理 断点续播的核心是记录用户播放中断位置,并在下次播放时恢复该位置。系统需要解决三个关键问题: 1. **进度持久化**:可靠存储用户的播放位置 2. **进度同步**:多设备间播放进度同步 3. **行为统计**:避免重复统计播放行为 #### 二、技术实现方案 ##### 1. 进度存储机制 - **数据结构**: - 用户ID、专辑ID、声音ID - 中断秒数(breakSecond) - 更新时间(用于确定最新进度) - **存储选择**: - 使用MongoDB文档数据库存储(适合非结构化数据) - 按用户ID分表存储(避免单表过大) - 查询优化:`limit(1)`确保只获取最新记录 ##### 2. 进度更新流程 1. **查询现有进度**: - 根据用户ID+声音ID查询MongoDB - 使用`findOne`获取最近一条记录 2. **记录处理**: - 不存在记录 &rarr; 创建新文档(设置初始值) - 存在记录 &rarr; 更新breakSecond和updateTime 3. **持久化操作**: - 使用`mongoTemplate.save()`保存到对应集合 4. **防重统计**: - 使用Redis SETNX实现24小时内只统计一次 - Key设计:`user_track_repeat_stat:{userId}:{trackId}` - TTL设置为当日剩余毫秒数 ##### 3. 播放行为统计 1. **首次更新触发**: - 当SETNX返回true时(表示首次设置) - 构建Kafka消息体(含业务唯一ID) 2. **消息内容**: - 专辑ID、声音ID - 统计类型(播放) - 计数增量(+1) 3. **消息发送**: - 发送到TRACK_STAT_UPDATE队列 - 消费者端做幂等处理 ##### 4. 进度查询流程 1. **请求参数**: - 用户ID(从认证上下文获取) - 声音ID(路径参数) 2. **数据库查询**: - 根据用户ID+声音ID查询MongoDB - 按更新时间倒序取第一条 3. **结果返回**: - 存在记录 &rarr; 返回breakSecond - 无记录 &rarr; 返回0(从头播放) #### 三、关键优化点 1. **并发处理**: - 使用MongoDB的原子操作`findAndModify` - 避免小程序暂停/恢复导致多条进度记录 2. **跨设备同步**: - 设备变更时触发同步事件 - 通过Kafka广播同步消息 - 各设备更新本地进度存储 3. **异常处理**: - MongoDB不可用时降级到Redis缓存 - Kafka消息发送失败时重试+死信队列 - 时钟偏移增加10%缓冲时间 4. **统计精确性**: - 业务唯一ID确保消息幂等性 - Redis+MySQL双重防重机制 - 分布式锁保证统计准确性 #### 四、架构优势 1. **存储分层**: - MongoDB:灵活存储播放进度 - Redis:高效防重控制 - MySQL:持久化统计数据 2. **解耦设计**: ```mermaid graph LR A[客户端] --&gt;|更新进度| B[播放服务] B --&gt;|写进度| C[MongoDB] B --&gt;|防重检查| D[Redis] B --&gt;|统计事件| E[Kafka] E --&gt; F[统计服务] E --&gt; G[推荐服务] ``` 3. **扩展能力**: - 支持历史进度回溯 - 可扩展播放行为分析 - 适配多终端类型
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值