redis点赞关注

已于 2023-09-04 13:21:58 修改
阅读量143 收藏 1
点赞数
分类专栏： redis 文章标签： java 开发语言
于 2023-03-11 23:42:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bubbleJessica/article/details/129421262
版权

发布探店笔记

@Resource
    private IBlogService blogService;


    @PostMapping
    public Result saveBlog(@RequestBody Blog blog) {
        // 获取登录用户
        UserDTO user = UserHolder.getUser();
        blog.setUserId(user.getId());
        // 保存探店博文
        blogService.save(blog);
        // 返回id
        return Result.ok(blog.getId());
    }

查看探店笔记+点赞

@PutMapping("/like/{id}")
    public Result likeBlog(@PathVariable("id") Long id) {
        // 修改点赞数量
        return blogService.likeBlog(id);
    }

@GetMapping("/hot")
    public Result queryHotBlog(@RequestParam(value = "current", defaultValue = "1") Integer current) {
        return blogService.queryHotBlog(current);
    }

    @GetMapping("/{id}")
    public Result queryBlogById(@PathVariable("id") Long id){
        return blogService.queryBlogById(id);
    }
@Resource
    private IUserService userService;

    @Resource
    private StringRedisTemplate stringRedisTemplate;
    @Override
    public Result queryBlogById(Long id) {
        // 1.查询blog
        Blog blog = getById(id);
        if (blog==null) {
            return Result.fail("笔记不存在！");
        }
        // 2.查询blog有关的用户
        queryBlogUser(blog);
        // 3.查询blog是否被点赞
        isBlogLiked(blog);
        return Result.ok(blog);
    }

    private void isBlogLiked(Blog blog) {
        // 获取当前登录的用户
        Long userId = UserHolder.getUser().getId();
        // 判断当前登录的用户是否点赞过了
        String key="blog:liked:"+blog.getId();
        Boolean isMember = stringRedisTemplate.opsForSet().isMember(key, userId.toString());
        blog.setIsLike(BooleanUtil.isTrue(isMember));
    }

    private void queryBlogUser(Blog blog) {
        Long userId = blog.getUserId();
        User user = userService.getById(userId);
        blog.setName(user.getNickName());
        blog.setIcon(user.getIcon());
    }

    @Override
    public Result queryHotBlog(Integer current) {
        // 根据用户查询
        Page<Blog> page = query()
                .orderByDesc("liked")
                .page(new Page<>(current, SystemConstants.MAX_PAGE_SIZE));
        // 获取当前页数据
        List<Blog> records = page.getRecords();
        // 查询用户
        records.forEach(blog ->{
            queryBlogUser(blog);
            isBlogLiked(blog);
        });
        return Result.ok(records);
    }

    @Override
    public Result likeBlog(Long id) {
        // 获取当前登录的用户
        Long userId = UserHolder.getUser().getId();
        // 判断当前登录的用户是否点赞过了
        String key="blog:liked:"+id;
        Boolean isMember = stringRedisTemplate.opsForSet().isMember(key, userId.toString());
        // 如果未点赞过
        if (BooleanUtil.isFalse(isMember)) {
            // 点赞数+1
            boolean isSuccess = update().setSql("liked=liked+1").eq("id", id).update();
            if (isSuccess){
                // 存放用户信息到redis中set
                stringRedisTemplate.opsForSet().add(key,userId.toString());
            }
        }else {
            // 点赞过
            // 点赞数-1
            boolean isSuccess = update().setSql("liked=liked-1").eq("id", id).update();
            if (isSuccess){
                // 将用户信息从redis中移除
                stringRedisTemplate.opsForSet().remove(key,userId.toString());
            }
        }
        return Result.ok();
    }

点赞排行榜（set集合转为SortedSet集合）

@GetMapping("/likes/{id}")
    public Result queryBlogLikes(@PathVariable("id") Long id){
        return blogService.queryBlogLikes(id);
    }
package com.hmdp.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.BooleanUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.hmdp.dto.Result;
import com.hmdp.dto.UserDTO;
import com.hmdp.entity.Blog;
import com.hmdp.entity.User;
import com.hmdp.mapper.BlogMapper;
import com.hmdp.service.IBlogService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmdp.service.IUserService;
import com.hmdp.utils.SystemConstants;
import com.hmdp.utils.UserHolder;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

import static com.hmdp.utils.RedisConstants.BLOG_LIKED_KEY;
import static java.util.stream.Collectors.*;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author 虎哥
 * @since 2021-12-22
 */
@Service
public class BlogServiceImpl extends ServiceImpl<BlogMapper, Blog> implements IBlogService {

    @Resource
    private IUserService userService;

    @Resource
    private StringRedisTemplate stringRedisTemplate;

// 笔记详情接口（笔记相关用户，笔记点赞）
    @Override
    public Result queryBlogById(Long id) {
        // 1.查询blog
        Blog blog = getById(id);
        if (blog == null) {
            return Result.fail("笔记不存在！");
        }
        // 2.查询blog有关的用户
        queryBlogUser(blog);
        // 3.查询blog是否被点赞
        isBlogLiked(blog);
        return Result.ok(blog);
    }

// 首页接口（判断笔记是否被登录用户点赞过）
    private void isBlogLiked(Blog blog) {
        // 获取当前登录的用户
        UserDTO user = UserHolder.getUser();
        if (user == null) {
            return;
        }
        Long userId = user.getId();
        // 判断当前登录的用户是否点赞过了
        String key = BLOG_LIKED_KEY + blog.getId();
        Double score = stringRedisTemplate.opsForZSet().score(key, userId.toString());
        blog.setIsLike(score != null);
    }

// 首页，查看详情（每篇笔记对应的用户）
    private void queryBlogUser(Blog blog) {
        Long userId = blog.getUserId();
        User user = userService.getById(userId);
        blog.setName(user.getNickName());
        blog.setIcon(user.getIcon());
    }

// 首页分页查询
    @Override
    public Result queryHotBlog(Integer current) {
        // 根据用户查询
        Page<Blog> page = query()
                .orderByDesc("liked")
                .page(new Page<>(current, SystemConstants.MAX_PAGE_SIZE));
        // 获取当前页数据
        List<Blog> records = page.getRecords();
        // 查询用户
        records.forEach(blog -> {
            queryBlogUser(blog);
            isBlogLiked(blog);
        });
        return Result.ok(records);
    }

// 首页（每篇笔记点赞数量）
    @Override
    public Result likeBlog(Long id) {
        // 获取当前登录的用户
        Long userId = UserHolder.getUser().getId();
        // 判断当前登录的用户是否点赞过了
        String key = BLOG_LIKED_KEY + id;
        Double score = stringRedisTemplate.opsForZSet().score(key, userId.toString());
        // 如果未点赞过
        if (score == null) {
            // 点赞数+1
            boolean isSuccess = update().setSql("liked=liked+1").eq("id", id).update();
            if (isSuccess) {
                // 存放用户信息到redis中set
                stringRedisTemplate.opsForZSet().add(key, userId.toString(), System.currentTimeMillis());
            }
        } else {
            // 点赞过
            // 点赞数-1
            boolean isSuccess = update().setSql("liked=liked-1").eq("id", id).update();
            if (isSuccess) {
                // 将用户信息从redis中移除
                stringRedisTemplate.opsForZSet().remove(key, userId.toString());
            }
        }
        return Result.ok();
    }


// 笔记详情点赞排行榜
    @Override
    public Result queryBlogLikes(Long id) {
        String key = BLOG_LIKED_KEY + id;
        // 1.查询top5点赞用户 zrange key 0 4
        Set<String> top5 = stringRedisTemplate.opsForZSet().range(key, 0, 4);
        if (top5 == null || top5.isEmpty()) {
            return Result.ok(Collections.emptyList());
        }
        // 2.解析其中用户的ids
        List<Long> ids = top5.stream().map(Long::valueOf).collect(toList());
        // 3.根据id查询用户
        // 出现点赞顺序排行出错
        /*List<UserDTO> userDTOS = userService.listByIds(ids)
                .stream()
                .map(user -> BeanUtil.copyProperties(user, UserDTO.class))
                .collect(toList());*/

        String idStr = StrUtil.join(",", ids);    //[5,1] -> "5,1"
        // 根据用户id查询用户 where id in (5,1) order by field (id,5,1)
        List<UserDTO> userDTOS = userService.query().in("id", ids)
                .last("ORDER BY FIELD(id," + idStr + ")").list()
                .stream()
                .map(user -> BeanUtil.copyProperties(user, UserDTO.class))
                .collect(toList());
        // 4.返回
        return Result.ok(userDTOS);
    }
}

好友关注：实现关注和取关功能（隐含一个查询是否关注功能） 

@Override
    public Result follow(Long followUserId, Boolean isFollow) {
        // 获取登陆的用户
        Long userId = UserHolder.getUser().getId();
        // 1.判断到底是关注还是取关
        if (isFollow){
            // 2.关注，新增数据
            Follow follow = new Follow();
            follow.setUserId(userId);
            follow.setFollowUserId(followUserId);
            save(follow);
        }else {
            // 3.取关，删除
            // delete from tb_follow where user_id=? and follow_user_id=?
            remove(new QueryWrapper<Follow>().eq("user_id",userId).eq("follow_user_id",followUserId));
        }
        return Result.ok();
    }

    @Override
    public Result isFollow(Long followUserId) {
        // 获取登陆的用户
        Long userId = UserHolder.getUser().getId();
        // 1.查询是否关注 select count(*) from tb_follow where user_id=? and follow_user_id=?
        Integer count = query().eq("user_id", userId).eq("follow_user_id", followUserId).count();
        // 2.判断
        return Result.ok(count>0);
    }

实现共同关注功能（前面关注和取关数据不仅要保存到数据库中还要保存到redis中set集合）

// 关注
@Override
    public Result follow(Long followUserId, Boolean isFollow) {
        // 获取登陆的用户
        Long userId = UserHolder.getUser().getId();
        //
        String key="follows:"+userId;
        // 1.判断到底是关注还是取关
        if (isFollow){
            // 2.关注，新增数据
            Follow follow = new Follow();
            follow.setUserId(userId);
            follow.setFollowUserId(followUserId);
            boolean isSuccess=save(follow);
            if(isSuccess){
                // 把关注用户的id，放入redis的set集合 sadd userId followUserId
                stringRedisTemplate.opsForSet().add(key,followUserId.toString());
            }
        }else {
            // 3.取关，删除
            // delete from tb_follow where user_id=? and follow_user_id=?
            boolean isSuccess=remove(new QueryWrapper<Follow>().eq("user_id",userId).eq("follow_user_id",followUserId));
            if(isSuccess){
                // 把关注用户的id从redis的set集合移除
                stringRedisTemplate.opsForSet.remove(key);
            }
        }
        return Result.ok();
    }

/**
     * 共同关注
     * @param id 打算关注的目标用户id
     * @return
     */
    @Override
    public Result followCommons(Long id) {
        // 1.获取当前用户
        Long userId = UserHolder.getUser().getId();
        String key="follows:"+userId;
        // 2.求交集
        String key2="follows:"+id;
        // 登录用户和目标用户交集
        Set<String> intersect = stringRedisTemplate.opsForSet().intersect(key, key2);
        if (intersect==null||intersect.isEmpty()){
            return Result.ok(Collections.emptyList());
        }
        // 3.解析id集合
        List<Long> ids = intersect.stream().map(Long::valueOf).collect(Collectors.toList());
        // 4.查询用户
        List<UserDTO> users = userService.listByIds(ids).stream()
                .map(user -> BeanUtil.copyProperties(user, UserDTO.class))
                .collect(Collectors.toList());
        return Result.ok(users);
    }

feed流推送

拉模式：读扩散即up主张三李四王五发消息都存放到各自发件箱里(msg+时间戳)，然后其粉丝关注张三和李四，它就读取张三李四的发件箱并且根据时间戳排序依次存放到收件箱里，如果关注很多人，那么势必会延迟显示信息，不可取（适用于粉丝关注up主少的人群）

推模式：写扩散即up主张三李四就没有发件箱了，每发送消息都会写到各自粉丝的收件箱里，延时低，缺点就是up主本身没有发件箱，那么不得不把每条消息都写给每个粉丝的收件箱里，写了好几份，内存占用较高一个消息要写入n份（适用于被关注少的up主人群）

推模式实现关注推送 

@Override
    public Result saveBlog(Blog blog) {
        // 1.获取登录用户
        UserDTO user = UserHolder.getUser();
        blog.setUserId(user.getId());
        // 2.保存探店博文
        boolean isSuccess = save(blog);
        if (!isSuccess){
            return Result.fail("新增笔记失败！");
        }
        // 3.查询笔记作者的所有粉丝 被关注的人就是当前登录用户
        // select * from tb_follow where follow_user_id=?
        List<Follow> follows = followService.query().eq("follow_user_id", user.getId()).list();
        // 4.推送笔记id给所有粉丝
        for (Follow follow:follows){
            // 4.1获取粉丝id
            Long followId = follow.getUserId();
            // 4.2推送
            String key="feed:"+followId;
            stringRedisTemplate.opsForZSet().add(key,blog.getId().toString(),System.currentTimeMillis());
        }
        // 返回id
        return Result.ok(blog.getId());
    }

滚动分页查询（SortedSet数据结构）参数 

max: 当前时间戳 | 上一次查询的最小时间戳

min: 0        

offset: 0 | 在上一次结果中与最小时间戳一样的个数

count: 3

package com.hmdp.dto;

import lombok.Data;

import java.util.List;

@Data
public class ScrollResult {
    private List<?> list;
    private Long minTime;
    private Integer offset;
}

/**
     * 滚动分页查询
     * @param max
     * @param offset
     * @return
     */
    @GetMapping("/of/follow")
    public Result queryBlogOfFollow(@RequestParam("lastId") Long max,@RequestParam(value = "offset",defaultValue = "0") Integer offset){
        return blogService.queryBlogOfFollow(max,offset);
    }
@Override
    public Result queryBlogOfFollow(Long max, Integer offset) {
        // 1.获取当前用户
        Long userId = UserHolder.getUser().getId();
        // 2.查询收件箱
        // zrevrangebyscore key max min limit offset count
        String key = FEED_KEY + userId;
        Set<ZSetOperations.TypedTuple<String>> typedTuples = stringRedisTemplate.opsForZSet()
                .reverseRangeByScoreWithScores(key, 0, max, offset, 3);
        if (typedTuples == null || typedTuples.isEmpty()) {
            return Result.ok();
        }
        // 3.解析数据：blogId、minTime（时间戳）、offset
        List<Long> ids = new ArrayList<>(typedTuples.size());
        long minTime = 0;
        int os = 1;//最小值数量
        for (ZSetOperations.TypedTuple tuple : typedTuples) {
            // 4.1.获取id
            String idStr = (String) tuple.getValue();
            ids.add(Long.valueOf(idStr));
            // 4.2.获取时间戳
            long time = tuple.getScore().longValue();
            if (time == minTime) {
                os++;
            } else {
                minTime = time;
                os = 1;
            }
        }
        // 4.根据id查询blog
        String idStr=StrUtil.join(",",ids);
        List<Blog> blogs = query().in("id", ids).last("order by FIELD(id," + idStr + ")").list();
        for (Blog blog:blogs){
            // 查询blog有关的用户
            queryBlogUser(blog);
            // 查询blog是否被点赞
            isBlogLiked(blog);
        }
        // 5.封装并返回
        ScrollResult r = new ScrollResult();
        r.setList(blogs);
        r.setMinTime(minTime);
        r.setOffset(os);
        return Result.ok(r);
    }

注意：mp里面listByIds()是无序查找的使用in，要想有序得手动编写sql 

bubbleJessica
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis实现点赞、关注、取top榜单实现
qq_45243783的博客
12-07 1619
redis实现社交场景点赞关注
集合常用操作
陆多多的专栏
03-12 373
List 1.逗号拼接字符串转换List 使用Splitter Splitter.on(",").splitToList(fixRcmdPos.getRoomNos()).stream().map(Long::parseLong) 字符串split Arrays.asList(ids.split(",")).stream().map(s -> Long.parseLong(s.trim())) 2. List转逗号凭借字符串 使用StringUtils.join StringUtils.join(
list转数组，奇怪的写法
qq_29664475的博客
11-05 167
private Long[] getRoleIds(User user) { return Stream.of(user.getRoleIds().split(",")) .map(Long::valueOf) .collect(Collectors.toList()).toArray(new Long[0]); } 今天看到项目中，这个方法很奇怪，把llist中的long类型数据转成数组long类型，出现了这种写法lists.toArray(new Long[0])；没看明白。记录一下 https://
java PageUtil + stream 手动计算List 分页
qq_42553504的博客
07-22 1263
交代一下前言，数据是redis中查询 140,193,88,117 格式大概是这样。 需要切割为long类型的list数组。需要手动计算分页，去mongodb中查询数据。 这里我用的手动计算分页的是hutool工具包 import cn.hutool.core.util.PageUtil; 里面挺多实用的工具 <dependency> <groupId>cn.hutool</groupId> <artifactI...
java8的list＜String＞转list＜Long＞
当我谈编程时我谈些什么
07-22 1万+
String转Long List<Long>=stringList.stream().map(Long::valueOf).collect(Collectors.toList()); Long转String List<>=longList.stream().map(String::valueOf).collect(Collectors.toList());
使用redis构建简单的社交网站.pdf
06-07
点赞/喜欢：对帖子或评论的点赞。 2. 数据结构设计 用户数据：可以使用Redis的哈希（Hash）结构存储用户数据，例如user:。 关注/粉丝关系：可以使用集合（Set）或有序集合（Sorted Set）来存储关注者和粉丝。...
使用redis构建简单的社交网站.docx
06-08
构建简单的社交网站可以使用Redis作为后端存储，以下是一个基本的架构示例： ...计数器和排行榜：使用Redis的计数器和有序集合数据结构实现点赞数、转发数、阅读数等统计功能，还可以实现用户排行榜功能
构建简单的社交网站时，Redis 可以作为一个非常有用的工具来存储和管理各种数据 以下是一些在构建社交网站时可以使用 Redis
06-07
4. **点赞和评论**：可以使用 Redis 的集合结构来存储用户对消息的点赞情况，使用列表结构来存储消息的评论内容，从而实现点赞和评论功能。 5. **在线状态**：可以使用 Redis 的键值对结构来存储用户的在
SpringBoot+MySQL+Redis+MyBatis实现的校园论坛项目源代码+详细使用说明文档
06-16
利用Redis的zset并结合Redis实现点赞关注的功能 用户点赞关注后，使用kafka实现异步的发送系统通知 开发环境 构建工具：Apache Maven 集成开发工具: IntelliJ IDEA 2021 数据库：MySQL、Redis 应用服务器：Apache ...
来看看大厂的Redis面试题.pdf
11-02
redis常见面试题免费分享,喜欢的点赞关注一下哦,更多资料我整理完之后,一一发布. redis原理,常见场景,并发解决等全都有.我设置的是0积分,但是老被系统改,如果需要积分才能下载可以私信我.....
java8使用Lambda表达式list转map-含实例解释
qq_40603010的博客
04-13 1458
Public Map<String, String> findAllMap() { List courseTypeList = findAll(); if (ObjectUtils.isNotNull(courseTypeList)) return courseTypeList.stream().collect(Collectors.toMap(CourseType:: getTypeKey, CourseType::getTypeName)); } 解释： 目标：得到一个Map<str
Java基础之Stream的使用078
BASK2311的博客
12-24 1178
Stream 是 Java8 中处理集合的关键抽象概念，可以指定对集合进行的操作，可以执行复杂的查找、过滤、映射数据等操作，Stream API 提供了一种高效且易于使用的处理数据的方式。跳过元素，返回一个扔掉了前 n 个元素的流。接收一个Collector接口的实现，用于给Stream中元素做汇总的方法。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。，这两种改变的引入带来的是新的抽象方式。
如何从map中提取value并转换成long
weixin_33939380的博客
04-08 2158
old： taskReportDataDTO.setUv(Long.valueOf(hbaseData.get(HbaseColumnEnum.uv).toString())); new： taskReportDataDTO.setPv(MapUtils.getLong(hbaseData,HbaseColumnEnum.pv.name().toLowerCase(),...
longValue() && Long.valueOf()
qq_42990803的博客
03-10 9106
longValue() longValue()是Long类的一个方法，用来得到Long类中的数值；也就是将包装类中的数据拆箱成基本数据类型。 Long.valueOf(参数) Long.valueOf(参数)是将参数转换成long的包装类——Long；也就是把基本数据类型转换成包装类。 为什么使用Long时，推荐多使用valueOf方法，少使用parseLong方法？ 因为Long本身有缓存机制，缓存了-128到127范围内的Long，valueOf方法会从缓存中去拿值，如果命中缓存，会减少资源的开销，pa
Long.valueOf()作用
热门推荐
evilcry2012的专栏
03-30 1万+
Long.valueOf()作用 举报|  分享| 2013-09-26 11:03wow1396815 | 浏览 3087 次  悬赏：10  学习 long a = 101l; long b = Long.valueOf(a); System.out.println(b);//输出101 这个Long.valueOf有什么用?百度了一下好像是转型String,但是是用在L
Java8提供Stream常见操作
超威半导体
11-13 1016
Java Stream是1.8提供的一种流式处理集合的工具。Collection接口提供了 stream方法能够抽象成流，这样省去了迭代的很多写法，其用法灵活，下面列举了一些常用的操作。 List&amp;amp;lt;String&amp;amp;gt; stringList = Lists.newArrayList(); for (int i = 0; i &amp;amp;lt; 10; i++) { ...
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
最新发布
lx_nhs的博客
06-12 495
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
redis存储点赞关注信息的时候，都会涉及Redis的什么操作啊？就是说会触发后面什么流程？
04-23
当使用 Redis 存储点赞关注信息时，通常会使用 Redis 的以下操作： 1. sadd：将用户 ID 添加到点赞或关注的集合中。 2. srem：将用户 ID 从点赞或关注的集合中移除。 3. scard：获取点赞或关注的集合的大小。 4. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值