第5章 详情介绍.md 48 KB
谷粒随享
第5章 专辑/声音详情
学习目标：
- 专辑详情业务需求
- 专辑服务 1.专辑信息 2.分类信息 3.统计信息 4，主播信息
- 搜索/详情服务：汇总专辑详情数据
- 专辑包含声音列表（付费标识动态展示）
- MongoDB文档型数据库应用
- 基于MongoDB存储用户对于声音播放进度
- 基于Redis实现排行榜（将不同不同分类下包含各个维度热门专辑排行）
1、专辑详情
专辑详情页面渲染需要以下四项数据：
- albumInfo：当前专辑信息
- albumStatVo：专辑统计信息
- baseCategoryView：专辑分类信息
- announcer：专辑主播信息
因此接下来，我们需要在专辑微服务、用户微服务中补充RestFul接口实现 并且 提供远程调用Feign API接口给搜索微服务来调用获取。
在专辑搜索微服务中编写控制器汇总专辑详情所需数据：
以下是详情需要获取到的数据集
- 通过专辑Id 获取专辑数据{已存在}
- 通过专辑Id 获取专辑统计信息{不存在}
- 通过三级分类Id 获取到分类数据{已存在}
- 通过用户Id 获取到主播信息{存在}
1.1 服务提供方提供接口
1.1.1 根据专辑Id 获取专辑数据（已完成）
1.1.2 根据三级分类Id获取到分类信息(已完成)
1.1.3 根据用户Id 获取主播信息（已完成）
1.1.4 根据专辑Id 获取统计信息
YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/67
AlbumInfoApiController 控制器
/**
* 根据专辑ID查询专辑统计信息
*
* @param albumId
* @return
*/
@Operation(summary = "根据专辑ID查询专辑统计信息")
@GetMapping("/albumInfo/getAlbumStatVo/{albumId}")
public Result<AlbumStatVo> getAlbumStatVo(@PathVariable Long albumId) {
AlbumStatVo albumStatVo = albumInfoService.getAlbumStatVo(albumId);
return Result.ok(albumStatVo);
}
AlbumInfoService接口
/**
* 根据专辑ID查询专辑统计信息
*
* @param albumId
* @return
*/
AlbumStatVo getAlbumStatVo(Long albumId);
AlbumInfoServiceImpl实现类
/**
* 根据专辑ID查询专辑统计信息
*
* @param albumId
* @return
*/
@Override
public AlbumStatVo getAlbumStatVo(Long albumId) {
return albumInfoMapper.getAlbumStatVo(albumId);
}
albumInfoMapper.java
/**
* 根据专辑ID查询专辑统计信息
* @param albumId
* @return
*/
AlbumStatVo getAlbumStatVo(@Param("albumId") Long albumId);
albumInfoMapper.xml
<!--根据专辑ID查询专辑统计信息-->
<select id="getAlbumStatVo" resultType="com.atguigu.tingshu.vo.album.AlbumStatVo">
select
album_id,
max(if(stat_type='0401', stat_num, 0)) playStatNum,
max(if(stat_type='0402', stat_num, 0)) subscribeStatNum,
max(if(stat_type='0403', stat_num, 0)) buyStatNum,
max(if(stat_type='0404', stat_num, 0)) commentStatNum
from album_stat where album_id = #{albumId} and is_deleted = 0
group by album_id
</select>
service-album-client模块AlbumFeignClient 接口中添加
/**
* 根据专辑ID查询专辑统计信息
*
* @param albumId
* @return
*/
@GetMapping("/albumInfo/getAlbumStatVo/{albumId}")
public Result<AlbumStatVo> getAlbumStatVo(@PathVariable Long albumId);
AlbumDegradeFeignClient熔断类：
@Override
public Result<AlbumStatVo> getAlbumStatVo(Long albumId) {
log.error("[专辑服务]提供远程调用方法getAlbumStatVo执行服务降级");
return null;
}
1.2 服务调用方汇总数据
回显时，后台需要提供将数据封装到map集合中;
result.put("albumInfo", albumInfo); 获取专辑信息
result.put("albumStatVo", albumStatVo); 获取专辑统计信息
result.put("baseCategoryView", baseCategoryView); 获取分类信息
result.put("announcer", userInfoVo); 获取主播信息
YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/69
在service-search 微服务itemApiController 控制器中添加
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 = "专辑详情管理")
@RestController
@RequestMapping("api/search")
@SuppressWarnings({"all"})
public class itemApiController {
@Autowired
private ItemService itemService;
/**
* 根据专辑ID获取渲染详情页面专辑相关信息
* @param albumId
* @return {"announcer":{主播对象},"albumInfo":{专辑信息},"albumStatVo":{统计对象},"baseCategoryView":{分类对象}}
*/
@Operation(summary = "根据专辑ID获取渲染详情页面专辑相关信息")
@GetMapping("/albumInfo/{albumId}")
public Result<Map<String, Object>> getAlbumPageData(@PathVariable Long albumId){
Map<String, Object> map = itemService.getAlbumPageData(albumId);
return Result.ok(map);
}
}
接口与实现
package com.atguigu.tingshu.search.service;
import java.util.Map;
public interface ItemService {
/**
* 根据专辑ID获取渲染详情页面专辑相关信息
* @param albumId
* @return {"announcer":{主播对象},"albumInfo":{专辑信息},"albumStatVo":{统计对象},"baseCategoryView":{分类对象}}
*/
Map<String, Object> getAlbumPageData(Long albumId);
}
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.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executor;
@Slf4j
@Service
@SuppressWarnings({"all"})
public class ItemServiceImpl implements ItemService {
@Autowired
private AlbumFeignClient albumFeignClient;
@Autowired
private UserFeignClient userFeignClient;
@Autowired
private Executor threadPoolTaskExecutor;
/**
* 根据专辑ID获取渲染详情页面专辑相关信息
*
* @param albumId
* @return {"announcer":{主播对象},"albumInfo":{专辑信息},"albumStatVo":{统计对象},"baseCategoryView":{分类对象}}
*/
@Override
public Map<String, Object> getAlbumPageData(Long albumId) {
//1.创建响应结果Map对象:多线程对HashMap（线程不安全）进行并发写操作导致key被覆盖，造成死循环
//故采用线程安全Map集合-ConcurrentHashMap
Map<String, Object> map = new ConcurrentHashMap<>();
//2.封装专辑基本信息
CompletableFuture<AlbumInfo> albumInfoCompletableFuture = CompletableFuture.supplyAsync(() -> {
AlbumInfo albumInfo = albumFeignClient.getAlbumInfo(albumId).getData();
Assert.notNull(albumInfo, "专辑{}不存在！", albumId);
map.put("albumInfo", albumInfo);
return albumInfo;
}, threadPoolTaskExecutor);
//3.封装专辑统计信息
CompletableFuture<Void> albumStatVoCompletableFuture = CompletableFuture.runAsync(() -> {
AlbumStatVo albumStatVo = albumFeignClient.getAlbumStatVo(albumId).getData();
Assert.notNull(albumStatVo, "统计信息{}不存在！", albumId);
map.put("albumStatVo", albumStatVo);
}, threadPoolTaskExecutor);
//4.封装专辑分类信息
CompletableFuture<Void> baseCategoryViewCompletableFuture = albumInfoCompletableFuture.thenAcceptAsync(albumInfo -> {
BaseCategoryView categoryView = albumFeignClient.getCategoryView(albumInfo.getCategory3Id()).getData();
Assert.notNull(categoryView, "分类{}不存在！", albumInfo.getCategory3Id());
map.put("baseCategoryView", categoryView);
}, threadPoolTaskExecutor);
//5.封装主播信息
CompletableFuture<Void> announcerCompletableFuture = albumInfoCompletableFuture.thenAcceptAsync(albumInfo -> {
UserInfoVo userInfoVo = userFeignClient.getUserInfoVo(albumInfo.getUserId()).getData();
Assert.notNull(userInfoVo, "用户{}不存在！", albumInfo.getUserId());
map.put("announcer", userInfoVo);
}, threadPoolTaskExecutor);
//6.返回封装专辑相关信息Map对象
//6.1 组合异步任务
CompletableFuture.allOf(
albumInfoCompletableFuture,
albumStatVoCompletableFuture,
baseCategoryViewCompletableFuture,
announcerCompletableFuture
).join();
return map;
}
}
1.3 获取专辑声音列表
需求：根据专辑ID分页查询声音列表，返回当前页10条记录，对每条声音付费标识处理。关键点：哪个声音需要展示付费标识。
默认每个声音付费标识为：false
判断专辑付费类型：0101-免费、0102-vip免费、0103-付费
- 用户未登录
- 专辑类型不是免费，将除了免费可以试听声音外，将本页中其余声音付费标识设置：true
- 用户登录（获取是否为VIP）
- 不是VIP，或者VIP过期（除了免费以外声音全部设置为付费）
- 是VIP，专辑类型为付费 需要进行处理
- 统一处理需要付费情况
- 获取用户购买情况（专辑购买，或者声音购买）得到每个声音购买状态
- 判断根据用户购买情况设置声音付费标识
1.3.1 获取用户声音列表付费情况
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 控制器：
/**
* 检查专辑页中每一页中声音对应购买请求
* @param userId 用户ID
* @param albumId 专辑ID
* @param needCheckBuyStatuTrackIds 待检查购买情况声音ID列表（调用前免费试听去掉）
* @return {声音ID:购买情况} 购买情况：1：已购 0：未购
*/
@Operation(summary = "检查专辑页中每一页中声音对应购买请求")
@PostMapping("/userInfo/userIsPaidTrack/{userId}/{albumId}")
public Result<Map<Long, Integer>> userIsPaidTrack(
@PathVariable Long userId,
@PathVariable long albumId,
@RequestBody List<Long> needCheckBuyStatuTrackIds
){
Map<Long, Integer> buyState = userInfoService.userIsPaidTrack(userId, albumId, needCheckBuyStatuTrackIds);
return Result.ok(buyState);
}
UserInfoService接口：
/**
* 检查专辑页中每一页中声音对应购买请求
* @param userId 用户ID
* @param albumId 专辑ID
* @param needCheckBuyStatuTrackIds 待检查购买情况声音ID列表（调用前免费试听去掉）
* @return {声音ID:购买情况} 购买情况：1：已购 0：未购
*/
Map<Long, Integer> userIsPaidTrack(Long userId, long albumId, List<Long> needCheckBuyStatuTrackIds);
UserInfoServiceImpl实现类：
@Autowired
private UserPaidAlbumMapper userPaidAlbumMapper;
@Autowired
private UserPaidTrackMapper userPaidTrackMapper;
/**
* 检查专辑页中每一页中声音对应购买请求
*
* @param userId 用户ID
* @param albumId 专辑ID
* @param needCheckBuyStatuTrackIds 待检查购买情况声音ID列表（调用前免费试听去掉）
* @return {声音ID:购买情况} 购买情况：1：已购 0：未购
*/
@Override
public Map<Long, Integer> userIsPaidTrack(Long userId, long albumId, List<Long> needCheckBuyStatuTrackIds) {
Map<Long, Integer> buyState = new HashMap<Long, Integer>();
//1.判断用户是否已购专辑（说明专辑价格类型整张专辑购买）
//1.1 根据用户ID+专辑ID查询已购专辑表
LambdaQueryWrapper<UserPaidAlbum> userPaidAlbumLambdaQueryWrapper = new LambdaQueryWrapper<>();
userPaidAlbumLambdaQueryWrapper.eq(UserPaidAlbum::getUserId, userId);
userPaidAlbumLambdaQueryWrapper.eq(UserPaidAlbum::getAlbumId, albumId);
userPaidAlbumLambdaQueryWrapper.last("limit 1");
Long count = userPaidAlbumMapper.selectCount(userPaidAlbumLambdaQueryWrapper);
if (count > 0) {
//1.2 已购买专辑，将提交待检查购买情况声音ID列表购买情况设置为1
for (Long needCheckBuyStatuTrackId : needCheckBuyStatuTrackIds) {
buyState.put(needCheckBuyStatuTrackId, 1);
}
return buyState;
}
//2.判断用户是否购买过声音
//2.1 根据用户ID+专辑ID查询已购声音表得到已购声音集合
LambdaQueryWrapper<UserPaidTrack> userPaidTrackLambdaQueryWrapper = new LambdaQueryWrapper<>();
userPaidTrackLambdaQueryWrapper.eq(UserPaidTrack::getUserId, userId);
userPaidTrackLambdaQueryWrapper.eq(UserPaidTrack::getAlbumId, albumId);
userPaidTrackLambdaQueryWrapper.select(UserPaidTrack::getTrackId);
List<UserPaidTrack> userPaidTrackList = userPaidTrackMapper.selectList(userPaidTrackLambdaQueryWrapper);
//2.2 如果不存在已购声音,将提交待检查购买情况声音ID列表购买情况设置为0
if (CollectionUtil.isEmpty(userPaidTrackList)) {
for (Long needCheckBuyStatuTrackId : needCheckBuyStatuTrackIds) {
buyState.put(needCheckBuyStatuTrackId, 0);
}
return buyState;
}
//2.3 如果存在已购声音，判断将已购声音购买情况设置为：1 未购买设置为：0
List<Long> userPaidTrackIdList = userPaidTrackList.stream().map(UserPaidTrack::getTrackId).collect(Collectors.toList());
for (Long needCheckBuyStatuTrackId : needCheckBuyStatuTrackIds) {
if(userPaidTrackIdList.contains(needCheckBuyStatuTrackId)){
//说明已购买该声音
buyState.put(needCheckBuyStatuTrackId, 1);
}else{
//说明未购买该声音
buyState.put(needCheckBuyStatuTrackId, 0);
}
}
return buyState;
}
service-user-client模块中UserFeignClient 远程调用接口中添加：
/**
* 检查专辑页中每一页中声音对应购买请求
* @param userId 用户ID
* @param albumId 专辑ID
* @param needCheckBuyStatuTrackIds 待检查购买情况声音ID列表（调用前免费试听去掉）
* @return {声音ID:购买情况} 购买情况：1：已购 0：未购
*/
@PostMapping("/userInfo/userIsPaidTrack/{userId}/{albumId}")
public Result<Map<Long, Integer>> userIsPaidTrack(
@PathVariable Long userId,
@PathVariable long albumId,
@RequestBody List<Long> needCheckBuyStatuTrackIds
);
UserDegradeFeignClient熔断类：
@Override
public Result<Map<Long, Integer>> userIsPaidTrack(Long userId, long albumId, List<Long> needCheckBuyStatuTrackIds) {
log.error("[用户服务]提供远程调用userIsPaidTrack执行服务降级");
return null;
}
1.3.2 查询专辑声音列表
在service-album 微服务中添加控制器. 获取专辑声音列表时，我们将数据都统一封装到AlbumTrackListVo实体类中
YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/89
TrackInfoApiController控制器
/**
* 分页查询专辑声音列表-动态根据用户情况展示声音付费标识
*
* @param albumId
* @param page
* @param limit
* @return
*/
@GuiGuLogin(required = false)
@Operation(summary = "分页查询专辑声音列表-动态根据用户情况展示声音付费标识")
@GetMapping("/trackInfo/findAlbumTrackPage/{albumId}/{page}/{limit}")
public Result<Page<AlbumTrackListVo>> getAlbumTrackPage(
@PathVariable Long albumId,
@PathVariable int page,
@PathVariable int limit
) {
//1.获取当前用户ID-可能为空
Long userId = AuthContextHolder.getUserId();
//2.封装分页对象
Page<AlbumTrackListVo> pageInfo = new Page<>(page, limit);
//3.调用业务层获取用户声音列表
pageInfo = trackInfoService.getAlbumTrackPage(userId, albumId, pageInfo);
return Result.ok(pageInfo);
}
TrackInfoService接口：
/**
* 分页查询专辑声音列表-动态根据用户情况展示声音付费标识
*
* @param userId 用户ID
* @param albumId 专辑ID
* @param pageInfo 分页对象
* @return
*/
Page<AlbumTrackListVo> getAlbumTrackPage(Long userId, Long albumId, Page<AlbumTrackListVo> pageInfo);
TrackInfoServiceImpl实现类：
- 根据专辑Id 获取到专辑列表，
- 用户为空的时候，然后找出哪些是需要付费的声音并显示付费 isShowPaidMark=true
付费类型： 0101-免费 0102-vip付费 0103-付费
- 用户不为空的时候
- 判断用户的类型
- vip 免费类型
- 如果不是vip 需要付费
- 如果是vip 但是已经过期了 也需要付费
- 需要付费
- 统一处理需要付费业务
获取到声音Id列表集合 与 用户购买声音Id集合进行比较 将用户购买的声音存储到map中，key=trackId value = 1或0; 1:表示购买过，0：表示没有购买过
如果声音列表不包含，则将显示为付费，否则判断用户是否购买过声音，没有购买过设置为付费
@Autowired
private UserFeignClient userFeignClient;
/**
* 分页查询专辑声音列表-动态根据用户情况展示声音付费标识
*
* @param userId 用户ID
* @param albumId 专辑ID
* @param pageInfo 分页对象
* @return
*/
@Override
public Page<AlbumTrackListVo> getAlbumTrackPage(Long userId, Long albumId, Page<AlbumTrackListVo> pageInfo) {
//1.根据专辑ID查询声音列表-AlbumTrackListVo对象中付费标识 "isShowPaidMark" 默认为false
pageInfo = trackInfoMapper.getAlbumTrackPage(pageInfo, albumId);
//TODO 根据用户情况（是否登录，是否会员，是否购买）动态判断是否需要付费
//2.根据专辑ID查询专辑信息-得到专辑付费类型、专辑免费实体集数
AlbumInfo albumInfo = albumInfoMapper.selectById(albumId);
Assert.notNull(albumInfo, "专辑{}为空", albumId);
//付费类型: 0101-免费、0102-vip免费、0103-付费
String payType = albumInfo.getPayType();
Integer tracksForFree = albumInfo.getTracksForFree();
//3.处理用户未登录情况
if (userId == null) {
//3.1 专辑付费类型为：VIP免费 或者 付费 将除免费试听声音外，将其他声音付费标识设置为true
if (SystemConstant.ALBUM_PAY_TYPE_VIPFREE.equals(payType) || SystemConstant.ALBUM_PAY_TYPE_REQUIRE.equals(payType)) {
pageInfo.getRecords()
.stream().filter(vo -> vo.getOrderNum() > tracksForFree)
.forEach(vo -> {
//不免费声音全部设置：true
vo.setIsShowPaidMark(true);
});
}
} else {
//4.处理用户已登录情况
//4.1 远程调用用户服务获取用户信息-得到VIP标识及会员过期时间
Boolean isVIP = false;
UserInfoVo userInfoVo = userFeignClient.getUserInfoVo(userId).getData();
Assert.notNull(userInfoVo, "用户不存在！");
if (userInfoVo.getIsVip().intValue() == 1 && userInfoVo.getVipExpireTime().after(new Date())) {
//是VIP条件：标识=1 且 会员过期时间大于当前时间
isVIP = true;
}
//4.2 判断是否需要进一步判断用户购买情况
Boolean isNeedCheckBuyState = false;
//4.2.1 如果用户为普通用户 专辑 付费类型：VIP免费 需要进一步判断购买情况
if (!isVIP && SystemConstant.ALBUM_PAY_TYPE_VIPFREE.equals(payType)) {
isNeedCheckBuyState = true;
}
//4.2.2 所有用户 专辑 付费类型：付费 需要进一步判断购买情况
if (SystemConstant.ALBUM_PAY_TYPE_REQUIRE.equals(payType)) {
isNeedCheckBuyState = true;
}
//4.3 需要进一步判断用户购买情况
if (isNeedCheckBuyState) {
//4.3.1 远程调用用户服务：根据专辑ID+用户ID+当前页声音ID列表（将免费试听声音ID去掉）
//将本页中声音为免费试听ID排除掉
List<Long> needCheckBuyStateTrackIds = pageInfo.getRecords().stream()
.filter(vo -> vo.getOrderNum() > tracksForFree) //去除掉免费
.map(AlbumTrackListVo::getTrackId) //获取声音ID
.collect(Collectors.toList());
//获取本页中声音购买情况Map
Map<Long, Integer> buyStateMap = userFeignClient.userIsPaidTrack(userId, albumId, needCheckBuyStateTrackIds).getData();
//4.3.2 根据声音ID对应购买情况设置付费标识：如果用户未购买将付费标识设置：true 反之不需处理
//遍历当前页中声音列表（将免费试听去掉）判断购买情况Map如果购买结果为：0 将该声音付费标识设置true,反之（已购买）保持默认付费标识false即可
pageInfo.getRecords().stream()
.filter(vo -> vo.getOrderNum() > tracksForFree) //去除掉免费
.forEach(vo -> {
if (buyStateMap.get(vo.getTrackId()).intValue() == 0) {
//说明当前用户未购买该声音
vo.setIsShowPaidMark(true);
}
});
}
}
return pageInfo;
}
TrackInfoMapper接口：条件必须是当前已经开放并且是审核通过状态的数据,并且还需要获取到声音的播放量以及评论数量
/**
* 分页展示专辑下声音列表
* @param pageInfo 分页对象 MP会自动进行分页
* @param albumId 专辑ID
* @return
*/
Page<AlbumTrackListVo> getAlbumTrackPage(Page<AlbumTrackListVo> pageInfo, @Param("albumId") Long albumId);
TrackInfoMapper.xml 映射文件
动态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='0701', ts.stat_num, 0)) playStatNum,
max(if(ts.stat_type='0702', ts.stat_num, 0)) collectStatNum,
max(if(ts.stat_type='0703', ts.stat_num, 0)) praiseStatNum,
max(if(ts.stat_type='0704', 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 status = '0501' and ti.is_deleted = 0
group by ti.id
order by ti.order_num
<!--分页展示专辑下声音列表-->
<select id="getAlbumTrackPage" resultType="com.atguigu.tingshu.vo.album.AlbumTrackListVo">
select
ti.id trackId,
ti.track_title,
ti.cover_url,
ti.media_duration,
ti.order_num,
ti.create_time,
max(if(ts.stat_type='0701', ts.stat_num, 0)) playStatNum,
max(if(ts.stat_type='0702', ts.stat_num, 0)) collectStatNum,
max(if(ts.stat_type='0703', ts.stat_num, 0)) praiseStatNum,
max(if(ts.stat_type='0704', ts.stat_num, 0)) commentStatNum
from track_info ti inner join track_stat ts
on ts.track_id = ti.id
where ti.album_id = #{albumId} and status = '0501' and ti.is_deleted = 0
group by ti.id
order by order_num asc
</select>
测试：
- 手动增加用户购买专辑记录：user_paid_album
- 手动增加用户购买声音记录：user_paid_track
- 手动修改VIP会员：user_info
情况一：未登录情况，专辑付费类型：VIP免费 付费 查看声音列表->试听声音免费+其余都需要展示付费标识
情况二：登录情况
- 普通用户
- 免费 全部免费
- VIP付费 试听声音免费+用户购买过专辑/声音，未购买展示付费标识
- 付费：试听声音免费+用户购买过专辑/声音，未购买展示付费标识
- VIP用户
- 免费 全部免费
- VIP付费 全部免费
- 付费：试听声音免费+用户购买过专辑/声音，未购买展示付费标识
2、MongoDB文档型数据库
详情见：第5章 MongoDB入门.md
播放进度对应的实体类 UserListenProcess
3、声音详情
3.1 获取声音播放进度
在播放声音的时候，会有触发一个获取播放进度的控制器！因为页面每隔10s会自动触发一次保存功能，会将数据写入MongoDB中。所以我们直接从MongoDB中获取到上一次声音的播放时间即可！
YAPI接口：http://192.168.200.6:3000/project/11/interface/api/71
在 service-user 微服务的 UserListenProcessApiController 控制器中添加
/**
* 查询当前登录用户对指定声音播放进度
*
* @param trackId
* @return
*/
@GuiGuLogin(required = false)
@Operation(summary = "查询当前登录用户对指定声音播放进度")
@GetMapping("/userListenProcess/getTrackBreakSecond/{trackId}")
public Result<BigDecimal> getTrackBreakSecond(@PathVariable Long trackId) {
Long userId = AuthContextHolder.getUserId();
if (userId != null) {
BigDecimal bigDecimal = userListenProcessService.getTrackBreakSecond(userId, trackId);
return Result.ok(bigDecimal);
}
return Result.ok();
}
UserListenProcessService接口：
/**
* 查询当前登录用户对指定声音播放进度
* @param userId
* @param trackId
* @return
*/
BigDecimal getTrackBreakSecond(Long userId, Long trackId);
UserListenProcessServiceImpl实现类：
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({"all"})
public class UserListenProcessServiceImpl implements UserListenProcessService {
@Autowired
private MongoTemplate mongoTemplate;
/**
* 查询当前登录用户对指定声音播放进度
*
* @param userId
* @param trackId
* @return
*/
@Override
public BigDecimal getTrackBreakSecond(Long userId, Long trackId) {
//1.获取用户播放进度集合名称
String collectionName = MongoUtil.getCollectionName(MongoUtil.MongoCollectionEnum.USER_LISTEN_PROCESS, userId);
//2.构建查询对象 查询条件：用户ID+声音ID
Query query = new Query();
query.addCriteria(Criteria.where("userId").is(userId).where("trackId").is(trackId));
UserListenProcess userListenProcess = mongoTemplate.findOne(query, UserListenProcess.class, collectionName);
if (userListenProcess != null) {
return userListenProcess.getBreakSecond();
}
return new BigDecimal("0.00");
}
}
3.2 更新播放进度
页面每隔10秒左右更新播放进度.
- 更新播放进度页面会传递 专辑Id ，秒数，声音Id 。后台会将这个三个属性封装到UserListenProcessVo 对象中。然后利用MongoDB进行存储到UserListenProcess实体类中！
- 为了提高用户快速访问，将用户信息存储到缓存中。先判断当前用户Id 与 声音Id 是否存在，不存在的话才将数据存储到缓存，并且要发送消息给kafka。
- kafka 监听消息并消费，更新专辑与声音的统计数据。
3.2.1 更新MongoDB
YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/73
在 UserListenProcessApiController 控制器中添加
/**
* 保存/更新当前登录用户对指定声音播放进度
* @param userListenProcessVo
* @return
*/
@GuiGuLogin(required = false)
@Operation(summary = "保存/更新当前登录用户对指定声音播放进度")
@PostMapping("/userListenProcess/updateListenProcess")
public Result updateListenProcess(@RequestBody UserListenProcessVo userListenProcessVo){
Long userId = AuthContextHolder.getUserId();
if (userId != null) {
userListenProcessService.updateListenProcess(userId, userListenProcessVo);
}
return Result.ok();
}
UserListenProcessService接口：
/**
* 保存/更新当前登录用户对指定声音播放进度
* @param userListenProcessVo
* @return
*/
void updateListenProcess(Long userId, UserListenProcessVo userListenProcessVo);
UserListenProcessServiceImpl实现类：
@Autowired
private RedisTemplate redisTemplate;
@Autowired
private KafkaService kafkaService;
/**
* 保存/更新当前登录用户对指定声音播放进度;更新声音及所属专辑统计信息（播放量）
*
* @param userListenProcessVo
* @return
*/
@Override
public void updateListenProcess(Long userId, UserListenProcessVo userListenProcessVo) {
//1.获取用户播放进度集合名称
String collectionName = MongoUtil.getCollectionName(MongoUtil.MongoCollectionEnum.USER_LISTEN_PROCESS, userId);
//2.构建查询对象 查询条件：用户ID+声音ID
Query query = new Query();
Long trackId = userListenProcessVo.getTrackId();
query.addCriteria(Criteria.where("userId").is(userId).where("trackId").is(trackId));
UserListenProcess userListenProcess = mongoTemplate.findOne(query, UserListenProcess.class, collectionName);
//3.如果播放进度对象为空则新增播放进度
userListenProcessVo.setBreakSecond(userListenProcessVo.getBreakSecond().setScale(2, RoundingMode.HALF_UP));
if (userListenProcess == null) {
//3.1 拷贝VO中专辑ID，声音ID，播放进度
userListenProcess = BeanUtil.copyProperties(userListenProcessVo, UserListenProcess.class);
userListenProcess.setUserId(userId);
userListenProcess.setCreateTime(new Date());
userListenProcess.setUpdateTime(new Date());
} else {
//4.如果播放进度对象有值则更新播放进度时间及更新时间
userListenProcess.setUpdateTime(new Date());
userListenProcess.setBreakSecond(userListenProcessVo.getBreakSecond());
}
mongoTemplate.save(userListenProcess, collectionName);
//5.TODO 更新统计信息（MySQL,ElasticSearch） 业务要求：当天内对于统计数值限制最多增量+1
//5.1 采用redis String提供命令：set k v ex nx 实现
//5.1.1 构建key的值 前缀:用户ID_专辑ID_声音ID
Long albumId = userListenProcessVo.getAlbumId();
String key = RedisConstant.USER_TRACK_REPEAT_STAT_PREFIX + userId + "_" + albumId + "_" + trackId;
//5.1.2 计算过期时间：当天结束时间-当前系统时间
DateTime endofDayDateTime = DateUtil.endOfDay(new Date());
long ttl = endofDayDateTime.getTime() - DateUtil.currentSeconds();
//5.1.3 将Key尝试存入Redis
Boolean flag = redisTemplate.opsForValue().setIfAbsent(key, null, ttl, TimeUnit.MILLISECONDS);
//5.2 setnx成功，构建更新统计MQ对象，发送消息到指定话题
if (flag) {
//5.2.1 构建更新统计MQ对象
TrackStatMqVo mqVo = new TrackStatMqVo();
mqVo.setAlbumId(albumId);
mqVo.setTrackId(trackId);
mqVo.setStatType(SystemConstant.TRACK_STAT_PLAY_NAME);
mqVo.setCount(1);
//5.2.2 构建MQ消息唯一编号，在消费者端（专辑服务，搜索服务）确保消息幂等性
mqVo.setBusinessNo(IdUtil.fastSimpleUUID());
//5.2.2 发送MQ消息到话题
kafkaService.sendMessage(KafkaConstant.QUEUE_TRACK_STAT_UPDATE, JSON.toJSONString(mqVo));
}
}
3.2.2 更新MySQL统计信息
在service-album 微服务中添加监听消息：
package com.atguigu.tingshu.album.listener;
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.AlbumStatMqVo;
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.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;
/**
* @author: atguigu
* @create: 2024-05-17 15:53
*/
@Slf4j
@Component
public class AlbumReceiver {
@Autowired
private AlbumInfoService albumInfoService;
/**
* 监听更新统计消息，更新数据库中统计信息表（声音统计表、专辑统计表）
*
* @param record
*/
@KafkaListener(topics = KafkaConstant.QUEUE_TRACK_STAT_UPDATE)
public void updateStata(ConsumerRecord<String, String> record) {
String value = record.value();
if (StringUtils.isNotBlank(value)) {
log.info("[专辑服务]监听到更新统计消息：{}", value);
TrackStatMqVo mqVo = JSON.parseObject(value, TrackStatMqVo.class);
albumInfoService.updateStata(mqVo);
}
}
}
在TrackInfoService 中添加接口
/**
* 更新统计信息
* @param mqVo
*/
void updateStata(TrackStatMqVo mqVo);
在TrackInfoServiceImpl 中添加实现
updateStata(TrackStatMqVo mqVo) {
//1.业务要求同一更新统计MQ消息只能消费一次
String key = RedisConstant.BUSINESS_PREFIX + "album:" + mqVo.getBusinessNo();
Boolean flag = redisTemplate.opsForValue().setIfAbsent(key, null, 10, TimeUnit.MINUTES);
if (flag) {
//2.首次处理业务消息
try {
//2.1 修改声音统计信息
if (SystemConstant.TRACK_STAT_PLAY_NAME.equals(mqVo.getStatType())) {
//2.2 修改声音所属专辑统计信息
//更新 声音及专辑 播放量
trackInfoMapper.updateStat(mqVo.getTrackId(), SystemConstant.TRACK_STAT_PLAY, mqVo.getCount());
albumInfoMapper.updateStat(mqVo.getAlbumId(), SystemConstant.ALBUM_STAT_PLAY, mqVo.getCount());
} else if (SystemConstant.TRACK_STAT_COMMENT_NAME.equals(mqVo.getStatType())) {
trackInfoMapper.updateStat(mqVo.getTrackId(), SystemConstant.TRACK_STAT_COMMENT, mqVo.getCount());
albumInfoMapper.updateStat(mqVo.getAlbumId(), SystemConstant.ALBUM_STAT_COMMENT, mqVo.getCount());
}
//TODO 其他统计类型：声音收藏、点赞
} catch (Exception e) {
//如果业务逻辑更新统计数据库异常，将key删除，默认情况：Kakfa会再次投递消息（默认10次未设置重试话题）
redisTemplate.delete(key);
throw new RuntimeException(e);
}
}
}
TrackStatMapper.java 添加方法
/**
* 更新声音统计信息
* @param trackId
* @param statType
* @param count
*/
void updateStat(@Param("trackId") Long trackId, @Param("statType") String statType, @Param("count") Integer count);
映射文件
<!--更新声音统计信息-->
<update id="updateStat">
UPDATE track_stat set stat_num = stat_num + #{count} where track_id = #{trackId} and stat_type = #{statType} and is_deleted = 0
</update>
AlbumStatMapper.java 接口添加
/**
* 更新专辑统计信息
*
* @param albumId
* @param statType
* @param count
*/
void updateStat(@Param("albumId") Long albumId, @Param("statType") String statType, @Param("count") Integer count);
映射文件
<!--更新专辑统计信息-->
<update id="updateStat">
UPDATE album_stat set stat_num = stat_num + #{count} where album_id = #{albumId} and stat_type = #{statType} and is_deleted = 0
</update>
3.3 用户上次播放专辑声音
我们需要根据用户Id 来获取播放记录 ，需要获取到专辑Id 与声音Id 封装到map中然后返回数据即可！
YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/83
控制器 UserListenProcessApiController
/**
* 获取当前用户上次播放声音信息
*
* @return
*/
@GuiGuLogin(required = false)
@Operation(summary = "获取当前用户上次播放声音信息")
@GetMapping("userListenProcess/getLatelyTrack")
public Result<Map<String, Long>> getLatelyTrack() {
Long userId = AuthContextHolder.getUserId();
if (userId != null) {
Map<String, Long> map = userListenProcessService.getLatelyTrack(userId);
return Result.ok(map);
}
return Result.ok();
}
UserListenProcessService接口：
/**
* 获取当前用户上次播放声音信息
*
* @return
*/
Map<String, Long> getLatelyTrack(Long userId);
UserListenProcessServiceImpl实现类：
/**
* 获取当前用户上次播放声音信息
*
* @return
*/
@Override
public Map<String, Long> getLatelyTrack(Long userId) {
//1.获取用户播放进度集合名称
String collectionName = MongoUtil.getCollectionName(MongoUtil.MongoCollectionEnum.USER_LISTEN_PROCESS, userId);
//2.构建查询对象：查询条件-用户ID，排序字段-更新时间，限制返回一条记录
Query query = new Query(Criteria.where("userId").is(userId));
query.with(Sort.by(Sort.Direction.DESC, "updateTime"));
UserListenProcess userListenProcess = mongoTemplate.findOne(query, UserListenProcess.class, collectionName);
if(userListenProcess!=null){
Map<String, Long> map = new HashMap<>();
map.put("albumId", userListenProcess.getAlbumId());
map.put("trackId", userListenProcess.getTrackId());
return map;
}
return null;
}
3.4 获取声音统计信息
YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/75
统计声音需要更新的数据如下，我们将数据封装到一个实体类TrackStatVo中便于操作
在TrackInfoApiController 控制器中添加
/**
* 查询声音统计信息
* @param trackId 声音ID
* @return
*/
@Operation(summary = "查询声音统计信息")
@GetMapping("/trackInfo/getTrackStatVo/{trackId}")
public Result<TrackStatVo> getTrackStatVo(@PathVariable Long trackId){
TrackStatVo trackStatVo = trackInfoService.getTrackStatVo(trackId);
return Result.ok(trackStatVo);
}
TrackInfoService接口：
/**
* 查询声音统计信息
* @param trackId 声音ID
* @return
*/
TrackStatVo getTrackStatVo(Long trackId);
TrackInfoServiceImpl实现类：
/**
* 查询声音统计信息
* @param trackId 声音ID
* @return
*/
@Override
public TrackStatVo getTrackStatVo(Long trackId) {
return trackInfoMapper.getTrackStatVo(trackId);
TrackInfoMapper.java
/**
* 查询声音统计信息
* @param trackId
* @return
*/
TrackStatVo getTrackStatVo(@Param("trackId") Long trackId);
SQL
#需求：根据声音ID查询声音统计信息 封装到 TrackStatVo对象中
select
max(if(stat.stat_type = '0701', stat_num, 0)) playStatNum,
max(if(stat.stat_type = '0702', stat_num, 0)) collectStatNum,
max(if(stat.stat_type = '0703', stat_num, 0)) praiseStatNum,
max(if(stat.stat_type = '0704', stat_num, 0)) commentStatNum
from track_stat stat where stat.track_id = 20156 and is_deleted = 0;
explain select
max(if(stat.stat_type = '0701', stat_num, 0)) playStatNum,
max(if(stat.stat_type = '0702', stat_num, 0)) collectStatNum,
max(if(stat.stat_type = '0703', stat_num, 0)) praiseStatNum,
max(if(stat.stat_type = '0704', stat_num, 0)) commentStatNum
from track_stat stat where stat.track_id = 20156;
映射文件：
<!--查询声音统计信息-->
<select id="getTrackStatVo" resultType="com.atguigu.tingshu.vo.album.TrackStatVo">
select
max(if(stat.stat_type = '0701', stat_num, 0)) playStatNum,
max(if(stat.stat_type = '0702', stat_num, 0)) collectStatNum,
max(if(stat.stat_type = '0703', stat_num, 0)) praiseStatNum,
max(if(stat.stat_type = '0704', stat_num, 0)) commentStatNum
from track_stat stat where stat.track_id = #{trackId} and is_deleted = 0;
</select>
4、专辑Redis排行榜
手动调用一次更新，查看排行榜。后续会整合xxl-job 分布式定时任务调度框架做定时调用。
YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/77
service-album微服务中BaseCategoryApiController控制器中添加
/**
* 查询所有一级分类列表
*
* @return
*/
@Operation(summary = "查询所有一级分类列表")
@GetMapping("/category/findAllCategory1")
public Result<List<BaseCategory1>> getAllCategory1() {
LambdaQueryWrapper<BaseCategory1> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.select(BaseCategory1::getId);
List<BaseCategory1> list = baseCategoryService.list(queryWrapper);
return Result.ok(list);
}
AlbumFeignClient
/**
* 查询所有一级分类列表
*
* @return
*/
@GetMapping("/category/findAllCategory1")
public Result<List<BaseCategory1>> getAllCategory1();
AlbumDegradeFeignClient熔断类：
@Override
public Result<List<BaseCategory1>> getAllCategory1() {
log.error("远程调用专辑服务getAllCategory1服务降级");
return null;
}
YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/79
在SearchApiController 中添加控制器
/**
* 更新Redis中所有一级分类下不同排序字段TOP10专辑列表
* @return
*/
@Operation(summary = "更新Redis中所有一级分类下不同排序字段TOP10专辑列表")
@GetMapping("/albumInfo/updateLatelyAlbumRanking")
public Result updateLatelyAlbumRanking(){
searchService.updateLatelyAlbumRanking();
return Result.ok();
}
SearchService接口：
/**
* 更新Redis中所有一级分类下不同排序字段TOP10专辑列表
* @return
*/
void updateLatelyAlbumRanking();
SearchServiceImpl实现类：
/**
* 更新Redis中所有一级分类下不同排序字段TOP10专辑列表
*
* @return
*/
@Override
public void updateLatelyAlbumRanking() {
try {
//1.远程调用“专辑服务”得到所有一级分类，获取所有一级分类ID
List<BaseCategory1> list = albumFeignClient.getAllCategory1().getData();
if (CollectionUtil.isNotEmpty(list)) {
//2.遍历所有一级分类
List<Long> categoryIdList = list.stream().map(BaseCategory1::getId).collect(Collectors.toList());
for (Long category1Id : categoryIdList) {
//声明Rdis排行榜中Key-标识出分类
String key = RedisConstant.RANKING_KEY_PREFIX + category1Id;
//3.处理某个一级分类排行数据，遍历5种不同排序字段
String[] rankingDimensionArray = new String[]{"hotScore", "playStatNum", "subscribeStatNum", "buyStatNum", "commentStatNum"};
for (String dimension : rankingDimensionArray) {
//4.根据分类ID+排序字段检索ES获取TOP10专辑列表
SearchResponse<AlbumInfoIndex> searchResponse = elasticsearchClient.search(s ->
s.index(INDEX_NAME)
.query(q -> q.term(t -> t.field("category1Id").value(category1Id)))
.size(10)
.sort(s1 -> s1.field(f -> f.field(dimension).order(SortOrder.Desc))),
AlbumInfoIndex.class
);
List<Hit<AlbumInfoIndex>> hits = searchResponse.hits().hits();
if (CollectionUtil.isNotEmpty(hits)) {
//5.将当前分类，当前排序下top10存入Redis
List<AlbumInfoIndex> infoIndexList = hits.stream().map(hit -> hit.source()).collect(Collectors.toList());
//5.1 构建Redis中排行榜hash中field(hashKey)-标识出排序字段
String field = dimension;
//5.2 将当前分类下，当前排序字段 top10列表存入Redis
redisTemplate.opsForHash().put(key, field, infoIndexList);
}
}
}
}
} catch (Exception e) {
log.error("[搜索服务]更新Redis排行榜异常：{}", e);
throw new RuntimeException(e);
}
}
5、获取排行榜
点击排行榜的时候，能看到获取排行榜的地址
排行榜：key=ranking:category1Id field = hotScore 或 playStatNum 或 subscribeStatNum 或 buyStatNum 或albumCommentStatNum value=List
YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/81
SearchApiController 控制器中添加
/**
* 查询指定分类制定排行维度TOP10专辑
* @param category1Id
* @param dimension
* @return
*/
@Operation(summary = "查询指定分类制定排行维度TOP10专辑")
@GetMapping("/albumInfo/findRankingList/{category1Id}/{dimension}")
public Result<List<AlbumInfoIndex>> getRankingList(@PathVariable Long category1Id, @PathVariable String dimension){
List<AlbumInfoIndex> list = searchService.getRankingList(category1Id, dimension);
return Result.ok(list);
}
SearchService接口：
/**
* 查询指定分类制定排行维度TOP10专辑
* @param category1Id
* @param dimension
* @return
*/
List<AlbumInfoIndex> getRankingList(Long category1Id, String dimension);
SearchServiceImpl实现类：
/**
* 查询指定分类制定排行维度TOP10专辑
*
* @param category1Id
* @param dimension
* @return
*/
@Override
public List<AlbumInfoIndex> getRankingList(Long category1Id, String dimension) {
//声明Rdis排行榜中Key-标识出分类 方式一
String key = RedisConstant.RANKING_KEY_PREFIX + category1Id;
//Boolean flag = redisTemplate.opsForHash().hasKey(key, dimension);
//if (flag) {
// List<AlbumInfoIndex> list = (List<AlbumInfoIndex>) redisTemplate.opsForHash().get(key, dimension);
// return list;
//}
//方式二：通过获取绑定到指定Key的操作对象（决定操作哪个大Key）
BoundHashOperations<String, String, List<AlbumInfoIndex>> hashOps = redisTemplate.boundHashOps(key);
if (hashOps.hasKey(dimension)) {
List<AlbumInfoIndex> list = hashOps.get(dimension);
return list;
}
return null;
}