**谷粒随享**
## 第7章 专辑/声音详情
**学习目标：**
- 专辑详情业务需求
- 专辑服务 1.专辑信息 2.分类信息 3.统计信息 4，主播信息
- 搜索服务：汇总专辑详情数据
- 专辑包含**声音列表（付费标识动态展示）**
- MongoDB文档型数据库应用
- 基于**MongoDB**存储用户对于声音**播放进度**
- 基于Redis实现排行榜（将不同分类下包含各个维度热门专辑排行）
# 1、专辑详情
专辑详情页面渲染需要以下四项数据：
- **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 获取统计信息
> YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/67
**AlbumInfoApiController** 控制器
```java
/**
* 根据专辑ID查询专辑统计信息
*
* @param albumId
* @return
*/
@Operation(summary = "根据专辑ID查询专辑统计信息")
@Get
Mapping("/albumInfo/getAlbumStatVo/{albumId}")
public Result<AlbumStatVo> 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 albumInfo
Mapper.getAlbumStatVo(albumId);
}
```
**albumInfo
Mapper.java**
```java
/**
* 根据专辑ID查询专辑统计信息
*
* @param albumId
* @return
*/
AlbumStatVo getAlbumStatVo(@Param("albumId") Long albumId);
```
**albumInfo
Mapper.xml**
```sql
<!
--据专辑ID查询专辑统计信息
-->
<select id="getAlbumStatVo" resultType="com.atguigu.tingshu.vo.album.AlbumStatVo">
select
stat.album_id,
max(if(stat.stat_type='0401', stat.stat_num, 0)) playStatNum,
max(if(stat.stat_type='0402', stat.stat_num, 0)) subscribeStatNum,
max(if(stat.stat_type='0403', stat.stat_num, 0)) buyStatNum,
max(if(stat.stat_type='0404', stat.stat_num, 0)) commentStatNum
from album_stat stat
where stat.album_id = #{albumId} and stat.is_deleted = 0
group by stat.album_id
</select>
```
`service
-album
-client`模块**AlbumFeignClient** 接口中添加
```java
/**
* 根据专辑ID查询专辑统计信息
*
* @param albumId
* @return
*/
@Get
Mapping("/albumInfo/getAlbumStatVo/{albumId}")
public Result<AlbumStatVo> getAlbumStatVo(@PathVariable Long albumId);
```
**Albu
mDegradeFeignClient**熔断类：
```java
@Override
public Result<AlbumStatVo> getAlbumStatVo(Long albumId) {
log.error("[专辑模块]提供远程调用方法getAlbumStatVo服务降级");
return null;
}
```
## 1.2 服务调用方汇总数据
回显时，后台需要提供将数据封装到
map集合中;
```java
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` 微服务**ite
mApiController** 控制器中添加
```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.Get
Mapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.Request
Mapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.
Map;
@Tag(name = "专辑详情管理")
@RestController
@Request
Mapping("api/search")
@SuppressWarnings({"all"})
public class ite
mApiController {
@Autowired
private ItemService itemService;
/**
* 根据专辑ID查询专辑详情相关数据
*
* @param albumId
* @return
*/
@Operation(summary = "根据专辑ID查询专辑详情相关数据")
@Get
Mapping("/albumInfo/{albumId}")
public Result<
Map<String, Object>> getItemInfo(@PathVariable Long albumId) {
Map<String, Object>
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<String, Object> 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.Hash
Map;
import java.util.
Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHash
Map;
import java.util.concurrent.ThreadPoolExecutor;
@Slf4j
@Service
@SuppressWarnings({"all"})
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<String, Object> getItemInfo(Long albumId) {
//1.创建响应结果
Map对象 Hash
Map在多线程环境下并发读写线程不安全：导致
key覆盖；导致死循环
//采用线程安全:ConcurrentHash
Map
Map<String, Object>
mapResult = new ConcurrentHash
Map<>();
//2.远程调用专辑服务获取专辑基本信息
-封装albumInfo属性
CompletableFuture<AlbumInfo> albumInfoCompletableFuture = CompletableFuture.supplyAsync(()
-> {
AlbumInfo albumInfo = albumFeignClient.getAlbumInfo(albumId).getData();
Assert.notNull(albumInfo, "专辑：{}不存在", albumId);
mapResult.put("albumInfo", albumInfo);
return albumInfo;
}, threadPoolExecutor);
//3.远程调用专辑服务获取专辑统计信息
-封装albumStatVo属性
CompletableFuture<Void> albumStatCompletableFuture = CompletableFuture.runAsync(()
-> {
AlbumStatVo albumStatVo = albumFeignClient.getAlbumStatVo(albumId).getData();
Assert.notNull(albumStatVo, "专辑统计信息：{}不存在", albumId);
mapResult.put("albumStatVo", albumStatVo);
}, threadPoolExecutor);
//4.远程调用专辑服务获取专辑分类信息
-封装baseCategoryView属性
CompletableFuture<Void> baseCategoryViewCompletableFuture = albumInfoCompletableFuture.thenAcceptAsync(albumInfo
-> {
BaseCategoryView categoryView = albumFeignClient.getCategoryView(albumInfo.getCategory3Id()).getData();
Assert.notNull(categoryView, "分类：{}不存在", albumInfo.getCategory3Id());
mapResult.put("baseCategoryView", categoryView);
}, threadPoolExecutor);
//
5.远程调用用户服务获取主播信息
-封装announcer属性
CompletableFuture<Void> announcerCompletableFuture = albumInfoCompletableFuture.thenAcceptAsync(albumInfo
-> {
UserInfoVo userInfoVo = userFeignClient.getUserInfoVo(albumInfo.getUserId()).getData();
Assert.notNull(userInfoVo, "用户：{}不存在", albumInfo.getUserId());
mapResult.put("announcer", userInfoVo);
}, threadPoolExecutor);
//6.组合异步任务，阻塞等待所有异步任务执行完毕
CompletableFuture.allOf(
albumInfoCompletableFuture,
albumStatCompletableFuture,
baseCategoryViewCompletableFuture,
announcerCompletableFuture
).join();
return
mapResult;
}
}
```
## 1.3 获取专辑声音列表
查询时，评论数关键字属性：commentStatNum
需求：根据专辑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** 控制器：
```java
/**
* 该接口提供给给专辑服务，展示声音列表动态判断付费标识
* 判断当前用户某一页中声音列表购买情况
*
* @param userId 用户ID
* @param albumId 专辑ID
* @param needChackTrackIdList 待检查购买情况声音列表
* @return data:{声音ID：购买结果} 结果：1（已购）0（未购买）
*/
@Operation(summary = "判断当前用户某一页中声音列表购买情况")
@Post
Mapping("/userInfo/userIsPaidTrack/{userId}/{albumId}")
public Result<
Map<Long, Integer>> userIsPaidTrack(
@PathVariable Long userId,
@PathVariable Long albumId,
@RequestBody List<Long> needChackTrackIdList) {
Map<Long, Integer>
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<Long, Integer> userIsPaidTrack(Long userId, Long albumId, List<Long> needChackTrackIdList);
```
**UserInfoServiceImpl实现类**：
```java
@Autowired
private UserPaidAlbum
Mapper userPaidAlbum
Mapper;
@Autowired
private UserPaidTrack
Mapper userPaidTrack
Mapper;
/**
* 判断当前用户某一页中声音列表购买情况
*
* @param userId 用户ID
* @param albumId 专辑ID
* @param needChackTrackIdList 待检查购买情况声音列表
* @return data:{声音ID：购买结果} 结果：1（已购）0（未购买）
*/
@Override
public
Map<Long, Integer> userIsPaidTrack(Long userId, Long albumId, List<Long> needChackTrackIdList) {
//1.根据用户ID+专辑ID查询已购专辑表
LambdaQueryWrapper<UserPaidAlbum> userPaidAlbumLambdaQueryWrapper = new LambdaQueryWrapper<>();
userPaidAlbumLambdaQueryWrapper.eq(UserPaidAlbum::getAlbumId, albumId);
userPaidAlbumLambdaQueryWrapper.eq(UserPaidAlbum::getUserId, userId);
Long count = userPaidAlbum
Mapper.selectCount(userPaidAlbumLambdaQueryWrapper);
if (count > 0) {
//1.1 存在专辑购买记录
-用户购买过该专辑，将待检查声音列表购买情况设置为：1
Map<Long, Integer>
mapResult = new Hash
Map<>();
for (Long trackId : needChackTrackIdList) {
mapResult.put(trackId, 1);
}
return
mapResult;
}
//2. 不存在专辑购买记录
-根据用户ID+声音列表查询已购声音表
LambdaQueryWrapper<UserPaidTrack> userPaidTrackLambdaQueryWrapper = new LambdaQueryWrapper<>();
userPaidTrackLambdaQueryWrapper.eq(UserPaidTrack::getUserId, userId);
userPaidTrackLambdaQueryWrapper.in(UserPaidTrack::getTrackId, needChackTrackIdList);
//获取本页中已购买声音列表
List<UserPaidTrack> userPaidTrackList = userPaidTrack
Mapper.selectList(userPaidTrackLambdaQueryWrapper);
//2.1 不存在声音购买记录
-将待检查声音列表购买情况设置为：0
if (CollectionUtil.isEmpty(userPaidTrackList)) {
Map<Long, Integer>
mapResult = new Hash
Map<>();
for (Long trackId : needChackTrackIdList) {
mapResult.put(trackId, 0);
}
return
mapResult;
}
//2.2 存在声音购买记录
-循环判断待检查声音ID找出哪些是已购，哪些是未购买
List<Long> userPaidTrackIdList = userPaidTrackList.stream().
map(UserPaidTrack::getTrackId).collect(Collectors.toList());
Map<Long, Integer>
mapResult = new Hash
Map<>();
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（未购买）
*/
@Post
Mapping("/userInfo/userIsPaidTrack/{userId}/{albumId}")
public Result<
Map<Long, Integer>> userIsPaidTrack(
@PathVariable Long userId,
@PathVariable Long albumId,
@RequestBody List<Long> needChackTrackIdList);
```
**UserDegradeFeignClient熔断类**：
```java
@Override
public Result<
Map<Long, Integer>> userIsPaidTrack(Long userId, Long albumId, List<Long> needChackTrackIdList) {
log.error("[用户服务]提供远程调用方法userIsPaidTrack执行服务降级");
return null;
}
```
### 1.3.2 查询专辑声音列表
在`service
-album` 微服务中添加控制器. 获取专辑声音列表时，我们将数据都统一封装到**AlbumTrackListVo**实体类中
> 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 = "用于小程序端专辑页面展示分页声音列表，动态根据用户展示声音付费标识")
@Get
Mapping("/trackInfo/findAlbumTrackPage/{albumId}/{page}/{limit}")
public Result<Page<AlbumTrackListVo>> getAlbumTrackPage(@PathVariable Long albumId, @PathVariable Integer page, @PathVariable Integer limit) {
//1.获取用户ID
Long userId = AuthContextHolder.getUserId();
//2.封装分页对象
Page<AlbumTrackListVo> pageInfo = new Page<>(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<AlbumTrackListVo> getAlbumTrackPage(Page<AlbumTrackListVo> 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<AlbumTrackListVo> getAlbumTrackPage(Long userId, Long albumId, Page<AlbumTrackListVo> pageInfo) {
//1.根据专辑ID分页获取该专辑下包含声音列表（包含声音统计信息）
-默认声音付费标识为false
pageInfo = albumInfo
Mapper.getAlbumTrackPage(pageInfo, albumId);
//2.TODO 动态判断当前页中每个声音付费标识 关键点：找出付费情况
//2.根据专辑ID查询专辑信息
AlbumInfo albumInfo = albumInfo
Mapper.selectById(albumId);
Assert.notNull(albumInfo, "专辑：{}不存在", 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
-> albumTrackVo.getOrderNum() > albumInfo.getTracksForFree()) //过滤获取除免费试听以外声音
.collect(Collectors.toList())
.stream().forEach(albumTrackListVo
-> {
albumTrackListVo.setIsShowPaidMark(true);
});
}
} else {
//4.处理用户已登录情况
//4.1 远程调用用户服务获取用户信息得到用户身份
UserInfoVo userInfoVo = userFeignClient.getUserInfoVo(userId).getData();
Assert.notNull(userInfoVo, "用户{}不存在", 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 && new Date().after(userInfoVo.getVipExpire
Time())) {
isNeedCheckPayStatus = true;
}
}
//4.2.2 如果专辑付费类型 付费
if (SystemConstant.ALBUM_PAY_TYPE_REQUIRE.equals(payType)) {
//当前用户为普通用户或VIP会员过期
isNeedCheckPayStatus = true;
}
if (isNeedCheckPayStatus) {
//4.3 进一步确定用户是否购买专辑或声音
-远程调用用户服务获取本页中专辑或者声音购买情况
//本页中需要检查购买情况声音列表，过滤掉当前页免费试听声音
List<AlbumTrackListVo> needCheckTrackList = pageInfo.getRecords().stream()
.filter(albumTrackListVo
-> albumTrackListVo.getOrderNum() > albumInfo.getTracksForFree())
.collect(Collectors.toList());
//本页中需要检查购买情况声音ID列表，过滤掉当前页免费试听声音
List<Long> needCheckTrackIdList = needCheckTrackList.stream()
.
map(albumTrackListVo
-> albumTrackListVo.getTrackId())
.collect(Collectors.toList());
Map<Long, Integer> userPayStatusTrack
Map = userFeignClient.userIsPaidTrack(userId, albumId, needCheckTrackIdList).getData();
//4.4 循环当前页中声音列表
-跟返回用户购买情况声音集合逐一判断
needCheckTrackList.stream().forEach(needCheckTrack
-> {
Integer payStatus = userPayStatusTrack
Map.get(needCheckTrack.getTrackId());
if (payStatus.intValue() == 0) {
//4.
5 某个声音用户未购买，将设置付费标识 isShowPaidMark:true
needCheckTrack.setIsShowPaidMark(true);
}
});
}
}
return pageInfo;
}
```
**TrackInfo
Mapper接口**：条件必须是当前已经开放并且是审核通过状态的数据,并且还需要获取到声音的播放量以及评论数量
```java
/**
* 查询指定专辑下包含声音列表
*
* @param pageInfo
* @param albumId
* @return
*/
Page<AlbumTrackListVo> getAlbumTrackPage(Page<AlbumTrackListVo> pageInfo, @Param("albumId") Long albumId);
```
**TrackInfo
Mapper.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 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 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
<!
--分页获取专辑下声音列表
-->
<select id="getAlbumTrackPage" resultType="com.atguigu.tingshu.vo.album.AlbumTrackListVo">
select
ti.id trackId,
ti.track_title,
ti.media_duration,
ti.order_num,
ti.create_
time,
max(if(stat.stat_type='0701', stat.stat_num, 0)) playStatNum,
max(if(stat.stat_type='0702', stat.stat_num, 0)) collectStatNum,
max(if(stat.stat_type='0703', stat.stat_num, 0)) praiseStatNum,
max(if(stat.stat_type='0704', 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
</select>
```
测试：
- 手动增加用户购买专辑记录：**user_paid_album**
- 手动增加用户购买声音记录：**user_paid_track**
- 手动修改VIP会员：**user_info**
情况一：未登录情况，专辑付费类型：VIP免费 付费 查看声音列表
->试听声音免费+其余都需要展示付费标识
情况二：登录情况
- 普通用户
- 免费 全部免费
- VIP付费 试听声音免费+用户购买过专辑/声音，未购买展示付费标识
- 付费：试听声音免费+用户购买过专辑/声音，未购买展示付费标识
- VIP用户
- 免费 全部免费
- VIP付费 全部免费
- 付费：试听声音免费+用户购买过专辑/声音，未购买展示付费标识
时间处理：
```java
@Data
@Schema(description = "UserInfoVo")
public class UserInfoVo implements Serializable {
@Schema(description = "用户id")
private Long id;
@Schema(description = "微信openId")
private String wxOpenId;
@Schema(description = "nickname")
private String nickname;
@Schema(description = "主播用户头像图片")
private String avatarUrl;
@Schema(description = "用户是否为VIP会员 0:普通用户 1:VIP会员")
private Integer isVip;
@Schema(description = "当前VIP到期时间，即失效时间")
@Date
TimeFormat(
pattern = "yyyy
-MM
-dd"
)
@JsonFormat(
shape = JsonFormat.Shape.STRING,
pattern = "yyyy
-MM
-dd",
timezone = "GMT+8"
)
@JsonDeserialize
private Date vipExpire
Time;
}
```
# 2、MongoDB文档型数据库
详情见：**第6章 MongoDB入门.
md**
**播放进度**对应的实体类:
```java
@Data
@Schema(description = "UserListenProcess")
@Document
public class UserListenProcess {
@Schema(description = "id")
@Id
private String id;
@Schema(description = "用户id")
private Long userId;
@Schema(description = "专辑id")
private Long albumId;
@Schema(description = "声音id，声音id为0时，浏览的是专辑")
private Long trackId;
@Schema(description = "相对于音频开始位置的播放跳出位置，单位为秒。比如当前音频总时长60s，本次播放到音频第2
5s处就退出或者切到下一首，那么break_second就是2
5")
private BigDecimal breakSecond;
@Schema(description = "是否显示")
private Integer isShow;
@Schema(description = "创建时间")
private Date create
Time;
@Schema(description = "更新时间")
private Date update
Time;
}
```
# 3、声音详情
## 3.1 获取声音播放进度
在播放声音的时候，会有触发一个获取播放进度的控制器！因为页面每隔10s会自动触发一次保存功能，会将数据写入MongoDB中。所以我们直接从MongoDB中获取到上一次声音的播放时间即可！
> YAPI接口：http://192.168.200.6:3000/project/11/interface/api/71
在 `service
-user` 微服务的 **UserListenProcessApiController** 控制器中添加
```java
/**
* 获取当前用户收听声音播放进
*
* @param trackId
* @return
*/
@GuiGuLogin(required = false)
@Operation(summary = "获取当前用户收听声音播放进度")
@Get
Mapping("/userListenProcess/getTrackBreakSecond/{trackId}")
public Result<BigDecimal> 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({"all"})
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("userId").is(userId).and("trackId").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("0.00");
}
}
```
## 3.2 更新播放进度
页面每隔10秒左右更新播放进度.
1. 更新播放进度页面会传递 专辑Id ，秒数，声音Id 。后台会将这个三个属性封装到UserListenProcessVo 对象中。然后利用MongoDB进行存储到UserListenProcess实体类中！
2. 为了提高用户快速访问，将用户信息存储到缓存中。先判断当前用户Id 与 声音Id 是否存在，不存在的话才将数据存储到缓存，并且要发送消息给kafka。
3. kafka 监听消息并消费，更新专辑与声音的统计数据。
### 3.2.1 更新MongoDB
> YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/73
在 **UserListenProcessApiController** 控制器中添加
```java
/**
* 更新当前用户收听声音播放进度
* @param userListenProcessVo
* @return
*/
@GuiGuLogin(required = false)
@Operation(summary = "更新当前用户收听声音播放进度")
@Post
Mapping("/userListenProcess/updateListenProcess")
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("userId").is(userId).and("trackId").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.setCreate
Time(new Date());
userListenProcess.setUpdate
Time(new Date());
} else {
//3.如果播放进度存在
-更新进度
userListenProcess.setBreakSecond(userListenProcessVo.getBreakSecond());
userListenProcess.setUpdate
Time(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 + ":" + userListenProcessVo.getTrackId();
long ttl = DateUtil.endOfDay(new Date()).get
Time()
- System.current
TimeMillis();
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 1
5: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<String, String> record) {
String value = record.value();
if (StringUtils.isNotBlank(value)) {
log.info("[专辑服务]，监听到更新声音统计消息：{}", value);
TrackStatMqVo mqVo = JSON.parseObject(value, TrackStatMqVo.class);
albumInfoService.updateTrackStat(mqVo);
}
}
}
```
在**TrackInfoService** 中添加接口
```java
/**
* MQ监听更新声音统计信息
* @param mqVo
*/
void updateTrackStat(TrackStatMqVo mqVo);
```
在**TrackInfoServiceImpl** 中添加实现
```java
@Autowired
private AlbumStat
Mapper albumStat
Mapper;
@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 = "mq:" + mqVo.getBusinessNo();
try {
Boolean flag = redisTemplate.opsForValue().setIfAbsent(
key, mqVo.getBusinessNo(), 1,
TimeUnit.HOURS);
if (flag) {
//2.更新声音统计信息
trackStat
Mapper.updateStat(mqVo.getTrackId(), mqVo.getStatType(), mqVo.getCount());
//3.更新专辑统计信息(播放量、评论量只要声音+1，对应专辑也得+1)
if (SystemConstant.TRACK_STAT_PLAY.equals(mqVo.getStatType())) {
albumStat
Mapper.updateStat(mqVo.getAlbumId(), SystemConstant.ALBUM_STAT_PLAY, mqVo.getCount());
}
if (SystemConstant.TRACK_STAT_COMMENT.equals(mqVo.getStatType())) {
albumStat
Mapper.updateStat(mqVo.getAlbumId(), SystemConstant.ALBUM_STAT_COMMENT, mqVo.getCount());
}
}
} catch (Exception e) {
//如果更新数据库发送异常，事务会进行回滚，下次再次投递消息允许继续处理统一个消息
redisTemplate.delete(
key);
throw new Run
timeException(e);
}
}
```
**TrackStat
Mapper**.java 添加方法
```java
package com.atguigu.tingshu.album.
mapper;
import com.atguigu.tingshu.model.album.TrackStat;
import com.baomidou.mybatisplus.core.
mapper.Base
Mapper;
import org.apache.ibatis.annotations.*;
@
Mapper
public interface TrackStat
Mapper extends Base
Mapper<TrackStat> {
/**
* 更新声音统计信息
* @param trackId 声音ID
* @param statType 统计类型
* @param count 数量
*/
@Update("update track_stat set stat_num = stat_num + #{count} where track_id = #{trackId} and stat_type = #{statType}")
void updateStat(@Param("trackId") Long trackId, @Param("statType") String statType, @Param("count") Integer count);
}
```
**AlbumStat
Mapper**.java 接口添加
```java
package com.atguigu.tingshu.album.
mapper;
import com.atguigu.tingshu.model.album.AlbumStat;
import com.baomidou.mybatisplus.core.
mapper.Base
Mapper;
import org.apache.ibatis.annotations.
Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Update;
@
Mapper
public interface AlbumStat
Mapper extends Base
Mapper<AlbumStat> {
@Update("update album_stat set stat_num = stat_num + #{count} where album_id = #{albumId} and stat_type = #{statType}")
void updateStat(@Param("albumId") Long albumId, @Param("statType") String statType, @Param("count") Integer count);
}
```
## 3.3 专辑上次播放专辑声音
我们需要根据用户Id 来获取播放记录 ，需要获取到专辑Id 与声音Id 封装到
map中然后返回数据即可！
> YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/83
控制器 **UserListenProcessApiController**
```java
/**
* 获取当前用户上次播放专辑声音记录
*
* @return
*/
@GuiGuLogin
@Get
Mapping("/userListenProcess/getLatelyTrack")
public Result<
Map<String, Long>> getLatelyTrack() {
Long userId = AuthContextHolder.getUserId();
return Result.ok(userListenProcessService.getLatelyTrack(userId));
}
```
**UserListenProcessService接口：**
```java
/**
* 获取用户最近一次播放记录
* @param userId
* @return
*/
Map<String, Long> getLatelyTrack(Long userId);
```
**UserListenProcessServiceImpl实现类**：
```java
/**
* 获取用户最近一次播放记录
*
* @param userId
* @return
*/
@Override
public
Map<String, Long> getLatelyTrack(Long userId) {
//根据用户ID查询播放进度集合，按照更新时间倒序，获取第一条记录
//1.构建查询条件对象
Query query = new Query();
//1.1 封装用户ID查询条件
query.addCriteria(Criteria.where("userId").is(userId));
//1.2 按照更新时间排序
query.with(Sort.by(Sort.Direction.DESC, "update
Time"));
//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<String, Long>
mapResult = new Hash
Map<>();
mapResult.put("albumId", listenProcess.getAlbumId());
mapResult.put("trackId", listenProcess.getTrackId());
return
mapResult;
}
return null;
}
```
## 3.4 获取声音统计信息
> YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/7
5
统计声音需要更新的数据如下，我们将数据封装到一个实体类中便于操作
```java
@Data
@Schema(description = "用户声音统计信息")
public class TrackStatVo {
@Schema(description = "播放量")
private Integer playStatNum;
@Schema(description = "订阅量")
private Integer collectStatNum;
@Schema(description = "点赞量")
private Integer praiseStatNum;
@Schema(description = "评论数")
private Integer commentStatNum; //该属性需要修改
}
```
在**TrackInfoApiController** 控制器中添加
```java
/**
* 根据声音ID，获取声音统计信息
* @param trackId
* @return
*/
@Operation(summary = "根据声音ID，获取声音统计信息")
@Get
Mapping("/trackInfo/getTrackStatVo/{trackId}")
public Result<TrackStatVo> 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 trackInfo
Mapper.getTrackStatVo(trackId);
}
```
**TrackInfo
Mapper**.java
```java
/**
* 获取声音统计信息
* @param trackId
* @return
*/
@Select("select\n" +
" track_id,\n" +
" max(if(stat_type='0701', stat_num, 0)) playStatNum,\n" +
" max(if(stat_type='0702', stat_num, 0)) collectStatNum,\n" +
" max(if(stat_type='0703', stat_num, 0)) praiseStatNum,\n" +
" max(if(stat_type='0704', stat_num, 0)) commentStatNum\n" +
" from track_stat where track_id = #{trackId} and is_deleted=0\n" +
"group by track_id")
TrackStatVo getTrackStatVo(@Param("trackId") Long trackId);
```
**SQL**
```sql
# 根据声音ID查询指定声音统计信息 playStatNum collectStatNum praiseStatNum commentStatNum
select
track_id,
max(if(stat_type='0701', stat_num, 0)) playStatNum,
max(if(stat_type='0702', stat_num, 0)) collectStatNum,
max(if(stat_type='0703', stat_num, 0)) praiseStatNum,
max(if(stat_type='0704', stat_num, 0)) commentStatNum
from track_stat where track_id = 49162 and is_deleted=0
group by track_id
```
# 4、更新Redis排行榜
手动调用一次更新，查看排行榜。后续会整合xxl
-job 分布式定时任务调度框架做定时调用。
> YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/77
`service
-album `微服务中**BaseCategoryApiController**控制器中添加
```java
/**
* 查询所有一级分类列表
* @return
*/
@Operation(summary = "查询所有一级分类列表")
@Get
Mapping("/category/findAllCategory1")
public Result<List<BaseCategory1>> getAllCategory1() {
return Result.ok(baseCategoryService.list());
}
```
**AlbumFeignClient**
```java
/**
* 查询所有一级分类列表
* @return
*/
@Get
Mapping("/category/findAllCategory1")
public Result<List<BaseCategory1>> getAllCategory1();
```
**Albu
mDegradeFeignClient熔断类**：
```java
@Override
public Result<List<BaseCategory1>> getAllCategory1() {
log.error("[专辑模块Feign调用]getAllCategory1异常");
return null;
}
```
> YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/79
在**SearchApiController** 中添加控制器
```java
/**
* 为定时更新首页排行榜提供调用接口
* @return
*/
@Operation(summary = "为定时更新首页排行榜提供调用接口")
@Get
Mapping("/albumInfo/updateLatelyAlbumRanking")
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<BaseCategory1> category1List = albumFeignClient.getdAllCategory1().getData();
Assert.notNull(category1List, "一级分类为空");
//2.循环遍历1级分类列表，获取该分类下
5种不同排序方式榜单专辑
for (BaseCategory1 baseCategory1 : category1List) {
Long category1Id = baseCategory1.getId();
//3.在处理当前1级分类中，再次循环
5种不同排序方式得到具体榜单数据
//3.1 声明排序方式数组
String[] rankingDimensionArray =
new String[]{"hotScore", "playStatNum", "subscribeStatNum", "buyStatNum", "commentStatNum"};
for (String rankingDimension : rankingDimensionArray) {
//3.2 调用ES检索接口获取榜单数据
SearchResponse<AlbumInfoIndex> searchResponse = elasticsearchClient.search(
s
-> s.index(INDEX_NAME)
.query(q
-> q.term(t
-> t.field("category1Id").value(category1Id)))
.sort(sort
-> sort.field(f
-> f.field(rankingDimension).order(SortOrder.Desc)))
.size(10)
,
AlbumInfoIndex.class
);
//3.3 获取当前分类下某个排序方式榜单专辑列表
List<Hit<AlbumInfoIndex>> hits = searchResponse.hits().hits();
if (CollectionUtil.isNotEmpty(hits)) {
List<AlbumInfoIndex> list = hits.stream().
map(hit
-> 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("[搜索服务]更新排行榜异常：{}", e);
throw new Run
timeException(e);
}
}
```
#
5、获取排行榜
点击排行榜的时候，能看到获取排行榜的地址
排行榜：
key=ranking:category1Id field = hotScore 或 playStatNum 或 subscribeStatNum 或 buyStatNum 或albumCommentStatNum value=List<AlbumInfoIndexVo>
> YAPI接口地址：http://192.168.200.6:3000/project/11/interface/api/81
**SearchApiController** 控制器中添加
```java
/**
* 获取指定1级分类下不同排序方式榜单列表
-从Redis中获取
* @param category1Id
* @param dimension
* @return
*/
@Operation(summary = "获取指定1级分类下不同排序方式榜单列表")
@Get
Mapping("/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**接口：
```java
/**
* 获取指定1级分类下不同排序方式榜单列表
-从Redis中获取
* @param category1Id
* @param dimension
* @return
*/
List<AlbumInfoIndex> getRankingList(Long category1Id, String dimension);
```
**SearchServiceImpl实现类**：
```java
/**
* 获取指定1级分类下不同排序方式榜单列表
-从Redis中获取
*
* @param category1Id
* @param dimension
* @return
*/
@Override
public List<AlbumInfoIndex> getRankingList(Long category1Id, String dimension) {
//1.构建分类排行榜Hash结构
Key
String
key = RedisConstant.RANKING_
KEY_PREFIX + category1Id;
//2.获取Redis中hash结构中value
Boolean flag = redisTemplate.opsForHash().has
Key(
key, dimension);
if (flag) {
List<AlbumInfoIndex> list = (List) redisTemplate.opsForHash().get(
key, dimension);
return list;
}
return null;
}
```
结合上面的内容介绍断点续播的实现思路，不需要给出代码
针对聊天系统中因网络不稳定导致的消息重复发送问题，通过MD5算法生成唯一标识符实现消息去重，确保服务器能准确处理并响应每条消息。
扫一扫
1154
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
