使用redis完成点赞和关注数据

已于 2025-03-31 13:06:12 修改
阅读量227 收藏 1
点赞数 6
文章标签： redis java 数据库
于 2025-03-29 22:39:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Suk__/article/details/146713851
版权

需求描述

点赞和关注功能一般都会有排序的潜在需求 对应到redis就是有序集合zset 用时间戳表示分数
点赞为最早点赞的显示在前面 比如微信朋友圈点赞 所以直接取出即可
关注为最新的关注人显示在前面 所以要用倒序的命令reverseRange去取即可

点赞功能

sortedset存储方式

key: 前缀+blogId
value: 点赞的用户id
score: 当前时间戳

表结构设计

点赞表
CREATE TABLE `tb_user_blog_like` (
  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
  `blog_id` bigint NOT NULL COMMENT '帖子id',
  `user_id` bigint NOT NULL COMMENT '用户id',
  `created_at` timestamp NOT NULL COMMENT '创建时间',
  `updated_at` timestamp NOT NULL COMMENT '更新时间',
  `status` tinyint(1) NOT NULL DEFAULT '1' COMMENT '1点赞0未点赞',
  PRIMARY KEY (`id`),
  KEY `idx_user_id_blog_id` (`user_id`,`blog_id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=25 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci
关注表
CREATE TABLE `tb_follow` (
  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键',
  `user_id` bigint unsigned NOT NULL COMMENT '用户id',
  `follow_user_id` bigint unsigned NOT NULL COMMENT '被关联的用户id',
  `status` tinyint(1) NOT NULL DEFAULT '1' COMMENT '1关注0未关注',
  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `updated_at` timestamp NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE,
  KEY `idx_user_id_follow_user_id` (`user_id`,`follow_user_id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci ROW_FORMAT=COMPACT

点赞接口:

@PutMapping("/like/{id}")
public Result likeBlog(@PathVariable("id") Long id) {
    blogService.like(id);
    return Result.ok();
}

service:

    /**
     * like posts
     *
     * @param blogId
     */
    @Override
    public void like(Long blogId) {
        Long userId = UserHolder.getUser().getId();
        DefaultRedisScript<Object> redisScript = new DefaultRedisScript<>("" +
                "local blogId = ARGV[1];" +
                "local userId = ARGV[2];" +
                "local blogKey = KEYS[1] .. blogId;" +
                "local messageQueueKey = KEYS[2];" +
                "local score = redis.call('zscore', blogKey, userId);" +
                "if(score == false) then " +
                "local time = redis.call('time');" +
                "local nowMills = time[1] * 1000 + math.floor(time[2] / 1000);" +
                "redis.call('zadd', blogKey, nowMills, userId);" +
                "else " +
                "redis.call('zrem', blogKey, userId); " +
                "end; " +
                "redis.call('xadd', messageQueueKey, '*', 'userId', userId, 'blogId', blogId);" +
                "");
        stringRedisTemplate.execute(redisScript, Arrays.asList(BLOG_LIKED, BLOG_USER_STREAMS_LIKE), blogId.toString(), userId.toString());
    }
    public boolean isLike(String userId, String blogId) {
        return Optional.ofNullable(stringRedisTemplate.opsForZSet().score(BLOG_LIKED + blogId, userId)).orElse(Double.valueOf(0)) > 0;
    }

    public int getLiked(String blogId) {
        return stringRedisTemplate.opsForZSet().count(BLOG_LIKED + blogId, 0, System.currentTimeMillis()).intValue();
    }

使用lua脚本保证一致性 如果有userId就删掉 没有就添加 然后发送消息到队列供消费端消费回写db
开启一个线程去轮询消费:

@PostConstruct
private void initJob() {
    threadPoolExecutor.submit(new BlogLikeJob());
}

private class BlogLikeJob implements Runnable {

    private boolean updateLike(Long blogId, Long userId) {
        RLock rLock = redissonClient.getLock("lock:blog:update:like:" + blogId);
        try {
            boolean tryLock = rLock.tryLock(2L, TimeUnit.SECONDS);
            if (tryLock) {
                UserBlogLike userBlogLike = new UserBlogLike();
                userBlogLike.setUserId(userId);
                userBlogLike.setBlogId(blogId);
                Integer status = userBlogLikeService.exist(userBlogLike);
                int delta = Objects.nonNull(status) && status == 1 ? -1 : 1;
                Boolean success = transactionTemplate.execute(transactionStatus -> {
                    long updated = blogMapper.updateLike(blogId, delta);
                    long toggleLike;
                    if (Objects.isNull(status)) {
                        toggleLike = userBlogLikeService.insert(userBlogLike);
                    } else {
                        userBlogLike.setStatus(status == 1 ? 0 : 1);
                        toggleLike = userBlogLikeService.update(userBlogLike);
                    }
                    if (updated < 1 || toggleLike < 1) {
                        if (!transactionStatus.isCompleted()) {
                            transactionStatus.setRollbackOnly();
                        }
                    }
                    return updated > 1 && toggleLike > 1;
                });
                return Boolean.TRUE.equals(success);
            }
            return false;
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            if (rLock.isHeldByCurrentThread() && rLock.isLocked()) {
                rLock.unlock();
            }
        }
    }

    @Override
    public void run() {
        while (true) {
            try {
                List<MapRecord<String, Object, Object>> records = stringRedisTemplate.opsForStream().read(
                        Consumer.from("g1", "c1"),
                        StreamReadOptions.empty().count(1).block(Duration.ofSeconds(2)),
                        StreamOffset.create(BLOG_USER_STREAMS_LIKE, ReadOffset.lastConsumed())
                );
                if (Objects.isNull(records) || records.isEmpty()) {
                    continue;
                }
                MapRecord<String, Object, Object> record = records.get(0);
                Map<Object, Object> entries = record.getValue();
                Long blogId = Long.valueOf((String) entries.get("blogId"));
                Long userId = Long.valueOf(entries.get("userId").toString());
                log.info("消费点赞数据: blogId: {}, userId: {}", blogId, userId);
                boolean success = this.updateLike(blogId, userId);
                if (success) {
                    stringRedisTemplate.opsForStream().acknowledge(BLOG_USER_STREAMS_LIKE, "g1", record.getId());
                }
            } catch (Exception e) {
                log.info("handle update blog like exception: {}", e);
                handlePendingList();
            }
        }
    }


    private void handlePendingList() {
        int retries = 5;
        while (retries-- > 0) { // loop read
            try {
                // there is equal to "execute the XREADGROUP GROUP g1 c1 COUNT 1 STREAMS seckill:voucher:streams.orders 0" commands
                List<MapRecord<String, Object, Object>> mapRecords = stringRedisTemplate.opsForStream().read(
                        Consumer.from("g1", "c1"), // specify the group and customer
                        StreamReadOptions.empty().count(1), // specify the number of messages
                        StreamOffset.create(BLOG_USER_STREAMS_LIKE, ReadOffset.from("0")) // specify the streams which the messages read from, here are read from historical records
                );
                if (Objects.isNull(mapRecords) || mapRecords.isEmpty()) {
                    // messages pending queue is empty, end the process
                    break;
                }
                MapRecord<String, Object, Object> record = mapRecords.get(0); // get a id:entries map
                Map<Object, Object> entries = record.getValue();// get the entries map
                Long blogId = Long.valueOf(entries.get("blogId").toString());
                Long userId = Long.valueOf(entries.get("userId").toString());
                log.info("消费点赞数据: blogId: {}, userId: {}", blogId, userId);
                boolean success = this.updateLike(blogId, userId);
                if (success) {
                    stringRedisTemplate.opsForStream().acknowledge(BLOG_USER_STREAMS_LIKE, "g1", record.getId()); // acknowledge the success
                }
            } catch (Exception e) {
                log.info("handle pending-list update blog like exception: {}", e);
                try {
                    Thread.sleep(20); // re-read in 20ms later
                } catch (InterruptedException ex) {
                    throw new RuntimeException(ex);
                }
            }
        }
        log.info("handle pending-list update blog like failure");
    }
}

public boolean isLike(String userId, String blogId) {
    return Optional.ofNullable(stringRedisTemplate.opsForZSet().score(BLOG_LIKED + blogId, userId)).orElse(Double.valueOf(0)) > 0;
}

public int getLiked(String blogId) {
    return stringRedisTemplate.opsForZSet().count(BLOG_LIKED + blogId, 0, System.currentTimeMillis()).intValue();
}

和redis涉及写的操作都用lua保证原子性
获取点赞top5:

/**
  * 查询点赞用户Top5
  *
  * @param id
  * @return
  */
 @Override
 public List<UserDTO> queryLikedUsers(Long id) {
     String key = BLOG_LIKED + id;
     Set<String> ids = stringRedisTemplate.opsForZSet().range(key, 0, 4);
     if (Objects.isNull(ids) || ids.isEmpty()) {
         return Collections.emptyList();
     }
     return userService.findByIds(ids.stream().collect(Collectors.toList()));
 }

关注操作和点赞操作一个道理 直接上代码:
关注接口:

@PutMapping("/{id}/{follow}")
public Result updateFollow(@PathVariable Long id, @PathVariable Integer follow) {
    followService.updateFollow(id, follow);
    return Result.ok();
}

@Override
public void updateFollow(Long followUserId, Integer status) {
    DefaultRedisScript<Object> redisScript = new DefaultRedisScript<>("" +
            "local userId = ARGV[1];" +
            "local userFollowKey = KEYS[1] .. userId;" +
            "local followMessageQueueKey = KEYS[2];" +
            "local followUserId = ARGV[2];" +
            "local status = ARGV[3];" +
            "local score = redis.call('zscore', userFollowKey, followUserId);" +
            "if(status == '1' and score == false) then " +
            "local time = redis.call('time');" +
            "local nowMills = time[1] * 1000 + math.floor(time[2] / 1000);" +
            "redis.call('zadd', userFollowKey, nowMills, followUserId);" +
            "end; " +
            "if(status == '0' and score ~= false) then " +
            "redis.call('zrem', userFollowKey, followUserId);" +
            "end;" +
            "redis.call('xadd', followMessageQueueKey, '*', 'userId', userId, 'followUserId', followUserId, 'status', status); " +
            "");
    stringRedisTemplate.execute(redisScript, Arrays.asList(USER_FOLLOWS, USER_STREAM_FOLLOW), UserHolder.getUser().getId().toString(), followUserId.toString(), status.toString());
}

查询是否关注了某用户:

@Override
public int isFollow(Long userId) {
    Double exists = stringRedisTemplate.opsForZSet().score(USER_FOLLOWS + UserHolder.getUser().getId().toString(), userId.toString());
    return Optional.ofNullable(exists).orElse(Double.valueOf(0)) > 0 ? 1 : 0;
}

查询和某用户的共同关注:

@Override
public List<UserDTO> commonFollowFromCache(Long followedUserId) {
    String followUserKey = USER_FOLLOWS + followedUserId;
    Set<String> followIds = stringRedisTemplate.opsForZSet().reverseRange(followUserKey, 0, -1);
    if (Objects.isNull(followIds) || followIds.isEmpty()) {
        return Collections.emptyList();
    }

    String currentUserKey = USER_FOLLOWS + UserHolder.getUser().getId();
    Set<String> currentIds = stringRedisTemplate.opsForZSet().reverseRange(currentUserKey, 0, -1);

    List<String> interactionIds = interact(followIds.stream().collect(Collectors.toList()), currentIds.stream().collect(Collectors.toList()));

    return userService.findByIds(interactionIds);
}

public <T> List<T> interact(List<T> list, List<T> other) {
    List<T> largerList = list.size() == other.size() ? list : (list.size() > other.size() ? list : other);
    List<T> smallerList = list.size() == other.size() ? other : (list.size() < other.size() ? list : other);

    int i = 0;
    int index = 0;
    while (index < smallerList.size()) {
        T currentId = smallerList.get(index);
        if (largerList.contains(currentId)) {
            smallerList.set(i, currentId);
            i++;
        }
        index++;
    }
    return smallerList.subList(0, i);
}

关注数据也要落库的 开启一个线程轮询消费:

@PostConstruct
private void initJob() {
    threadPoolExecutor.submit(new UserFollowJob());
}

private class UserFollowJob implements Runnable {
    @Override
    public void run() {
        while (true) {
            try {
                List<MapRecord<String, Object, Object>> records = stringRedisTemplate.opsForStream().read(
                        Consumer.from("g1", "c1"),
                        StreamReadOptions.empty().count(1).block(Duration.ofSeconds(2)),
                        StreamOffset.create(USER_STREAM_FOLLOW, ReadOffset.lastConsumed())
                );
                if (Objects.isNull(records) || records.isEmpty()) {
                    continue;
                }
                MapRecord<String, Object, Object> record = records.get(0);
                Map<Object, Object> entries = record.getValue();
                Long userId = Long.valueOf(entries.get("userId").toString());
                Long followUserId = Long.valueOf((String) entries.get("followUserId"));
                Integer status = Integer.valueOf((String) entries.get("status"));
                log.info("消费关注数据: userId: {}, followUserId: {}, status: {}", userId, followUserId, status);
                boolean success = this.updateFollow(userId, followUserId, status);
                if (success) {
                    stringRedisTemplate.opsForStream().acknowledge(USER_STREAM_FOLLOW, "g1", record.getId());
                }
            } catch (Exception e) {
                log.info("handle update user follow exception: {}", e);
                handlePendingList();
            }
        }
    }

    private boolean updateFollow(Long userId, Long followUserId, Integer status) {
        RLock lock = redissonClient.getLock("lock:user:update:follow:" + userId);
        try {
            boolean tryLock = lock.tryLock(2L, TimeUnit.SECONDS);
            if (tryLock) {
                Follow newOrUpdatedFollow = new Follow();
                newOrUpdatedFollow.setUserId(userId);
                newOrUpdatedFollow.setFollowUserId(followUserId);
                long exists = followMapper.exist(newOrUpdatedFollow);
                newOrUpdatedFollow.setStatus(status);
                if (exists > 0) {
                    // 如果存在 更新status
                    long updated = followMapper.updateFollow(newOrUpdatedFollow);
                    return updated > 0;
                } else {
                    // 不存在 新插入
                    long inserted = followMapper.insertFollow(newOrUpdatedFollow);
                    return inserted > 0;
                }
            }
            return false;
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            if (lock.isHeldByCurrentThread() && lock.isLocked()) {
                lock.unlock();
            }
        }
    }

    private void handlePendingList() {
        int retries = 5;
        while (retries-- > 0) {
            try {
                List<MapRecord<String, Object, Object>> records = stringRedisTemplate.opsForStream().read(
                        Consumer.from("g1", "c1"),
                        StreamReadOptions.empty().count(1).block(Duration.ofSeconds(2)),
                        StreamOffset.create(USER_STREAM_FOLLOW, ReadOffset.from("0"))
                );
                if (Objects.isNull(records) || records.isEmpty()) {
                    break;
                }
                MapRecord<String, Object, Object> record = records.get(0);
                Map<Object, Object> entries = record.getValue();
                Long userId = Long.valueOf(entries.get("userId").toString());
                Long followUserId = Long.valueOf((String) entries.get("followUserId"));
                Integer status = Integer.valueOf((String) entries.get("status"));
                log.info("消费关注数据: userId: {}, followUserId: {}, status: {}", userId, followUserId, status);
                boolean success = this.updateFollow(userId, followUserId, status);
                if (success) {
                    stringRedisTemplate.opsForStream().acknowledge(USER_STREAM_FOLLOW, "g1", record.getId());
                }
            } catch (Exception e) {
                log.info("handle update user follow exception: {}", e);
                try {
                    Thread.sleep(20);
                } catch (InterruptedException ex) {
                    throw new RuntimeException(ex);
                }
            }
        }
        log.info("handle update user follow failure");
    }
}
williamyi74
关注
巧用 redis 实现点赞功能，它不比 mysql 香吗？
java_beautiful的博客
06-29 2564
提到点赞，大家一想到的是不是就是朋友圈的点赞呀？其实点赞对我们来说并不陌生，我们经常会在手机软件或者网页中看到它，今天就让我们来了解一下它的实现吧。我们常见的设计思路大概分为两种：一种自然是用 MySQL 等数据库直接落地存储， 另外一种就是将点赞的数据保存到 Redis 等缓存里，在一定时间后刷回 MySQL 等数据库。...
大厂面试官问我：Redis处理点赞，如果瞬时涌入大量用户点赞（千万级），应当如何进行处理？【后端八股文一：Redis点赞八股文合集】
qq_33445788的博客
06-21 1873
在面试当中，面试官经常对项目亮点进行深挖，来考察你对这个项目亮点的理解以及思考！这个时候，你如果可以回答出面试官的问题，甚至是，那在面试中是大大加分的~
利用Redis实现点赞功能
qq_43514659的博客
08-17 3483
点赞功能 咳咳，点赞功能哈，这是一个非常高频的操作，所以我们这里选择 redis 来存取数据哈 开发点赞业务 因为我们之前用 Spring 整合 Redis 的时候，已经做了 命名的规定。 我们利用 RedisTemplate 这个Bean 操作数据库。 点赞 // 点赞 public void like(int userId,int entityType,int entityId){ String entityLikeKey = RedisKeyUtil.getEn
Redis应用---Redis实现点赞点踩功能
zhangpower1993的博客
04-07 6616
为什么使用Redis而不是MySQL实现? Redis 和 MySQL应用场景不同。 从效率来说: Redis的数据存放在内存，所以速度快但是会受到内存空间限制。 MySQL存放在硬盘，在速度上肯定没有Redis快，但是存放的数据量要多的多。 从功能来说： Redis是一个K-V数据库，同时还支持List/Hash/Set/Sorted Set等几个简单数据结构，所以只能以这些数...
redis实现点赞功能。
weixin_51472505的博客
08-23 6175
redis实现点赞功能。
Redis实现点赞功能模块
wanghao112956的博客
10-16 3651
之前看了一篇文章，讲redis的应用场景，其中一个应用场景就是实现点赞功能，纸上得来恐觉浅，必须实战一波 功能点设计 比如我喜欢发文章的掘金网站就有点赞的功能，统计文章点赞的总数，用户所有文章的点赞数，因此设计的点赞功能模块具有以下功能点： 某篇文章的点赞数 用户所有文章的点赞数 用户点赞的文章 持久化到MySQL数据库 数据库设计 Redis数据库设计 Redis是K-V数据库，没有统...
使用redis实现点赞功能的几种思路
热门推荐
huangchunxia_1的博客
05-28 1万+
转载自：https://kikoroc.com/2016/06/07/dev-like-function-with-redis.html点赞功能几乎是现在互联网产品的标配了，点赞存在的意思还是蛮有趣的为什么社交网站的评价功能多采用「点赞」的模式？。本文主要介绍本人工作中遇到的点赞需求以及使用redis的解决思路。第一种点赞需求是比较常规的点赞需求，类似于微博那种点赞模式，用户可以对某条信息点赞、取...
java使用Redis实现点赞功能
kires的博客
02-28 4348
疑问 当看到这个标题，可能会有些大佬有点模糊，因为为什么不用数据库去实现，而用redis来实现这个功能，那我们可以一起来思考一下。 为什么实现redis，而不用数据库 先从安全方面来讲，如果使用数据库，假如用户频繁点赞，取消点赞这些操作的话，那么会给数据库造成压力，如果使用缓存的话，那么压力不会那么大。 从效率方面考虑，redis数据存在与内存，所以速度收到内存影响，数据库存在与硬盘，速度没redis快。 从功能方面考虑，redis只支持几种数据结构，没用数据库支持的多。 Redis几种数据结构的适用场
php怎么用redis实现点赞功能,Redis实现点赞功能模块
weixin_33323907的博客
03-22 324
之前看了一篇文章，讲redis的应用场景，其中一个应用场景就是实现点赞功能，纸上得来恐觉浅，必须实战一波功能点设计比如我喜欢发文章的掘金网站就有点赞的功能，统计文章点赞的总数，用户所有文章的点赞数，因此设计的点赞功能模块具有以下功能点：某篇文章的点赞数用户所有文章的点赞数用户点赞的文章持久化到MySQL数据库数据库设计Redis数据库设计Redis是K-V数据库，没有统一的数据结构，针对不同的功能...
基于SpringBoot+Redis实现点赞/排行榜功能，可同理实现收藏/关注功能，可拓展实现共同好友/共同关注/关注推送功能
都随它大小便吧
11-22 2855
简单记录一下在SpringBoot项目中，使用Redis实现点赞/排行榜功能，可同理实现收藏/关注功能，可拓展实现共同好友/共同关注/关注推送功。主要用到了Redis中的Set集合和ZSet集合。
巧用redis实现点赞功能，它不比mysql香吗？
阿Q的小窝
01-19 4102
提到点赞，大家一想到的是不是就是朋友圈的点赞呀？其实点赞对我们来说并不陌生，我们经常会在手机软件或者网页中看到它，今天就让我们来了解一下它的实现吧。我们常见的设计思路大概分为两种：一种自然是用MySQL等数据库直接落地存储， 另外一种就是将点赞的数据保存到Redis等缓存里，在一定时间后刷回MySQL等数据库。 首先我们来说一下两种方法各自的优缺点：我们以MySQL和Redis为例。 1、直接写入数据库： **优点：**这种方法实现简单，只需完成数据库的增删改查就行； 缺点： 数据库读写压力大，如果遇到热门
用redis实现点赞功能
m0_51587250的博客
12-18 2591
本文基于 SpringCloud, 用户发起点赞、取消点赞后先存入 Redis 中，再每隔两小时从 Redis 读取点赞数据写入数据库中做持久化存储。 点赞功能在很多系统中都有，但别看功能小，想要做好需要考虑的东西还挺多的。 点赞、取消点赞是高频次的操作，若每次都读写数据库，大量的操作会影响数据库性能，所以需要做缓存。 至于多久从 Redis 取一次数据存到数据库中，根据项目的实际情况定吧，我是暂时设了两个小时。 项目需求需要查看都谁点赞了，所以要存储每个点赞的点赞人、被点赞人，不能简单的做计数。 文章分四
redis实现点赞功能模块.rar
12-28
在IT行业中，数据库缓存系统在提升应用性能方面起着至关重要的作用，而Redis作为一款高性能的键值存储系统，常被用于实现如点赞、关注等实时性需求高的功能。本项目通过Java与Redis的集成，实现了点赞功能模块，特别...
点赞模块设计 - Redis缓存 + 定时写入数据库实现高性能点赞功能
m0_74931226的博客
12-14 766
点赞功能在很多系统中都有，但别看功能小，想要做好需要考虑的东西还挺多的。 点赞、取消点赞是高频次的操作，若每次都读写数据库，大量的操作会影响数据库性能，所以需要做缓存。 至于多久从 Redis 取一次数据存到数据库中，根据项目的实际情况定吧，我是暂时设了两个小时。 项目需求需要查看都谁点赞了，所以要存储每个点赞的点赞人、被点赞人，不能简单的做计数。
Redis-事务
m0_45253972的博客
04-12 143
Redis的设计更倾向于性能，而不是为了像数据库一样，保证事务的一致性而且牺牲性能。Redis的事务用的并不多，通过Lua脚本也可以保证多个命令执行的原子性，并且性能还会更好。因为通过Lua脚本，它会将多个命令打包，一起放到Redis的服务端进行执行。，这些队列中的命令才会执行。在这个过程中如果某一个命令发生异常，不会导致所有的命令回滚，而是忽略异常命令，继续执行其它命令。数据库的事务就是开启事务，然后执行数据库的一系列操作，如果没有异常就会提交事务，如果出现异常就会回滚事务。
Redis核心功能实现
pass_JMC的博客
04-11 681
redis对自己的定义是--Redis官方介绍 -2025/4/8其实就是一个开源的内存数据库，但是它提到三个重要的词语，这也是它主打的东西fastest：关于这点，类似绝对的宣传听说在欧美是违法的，作者在编写文章时已经向欧盟提交了举报。simple：使用redis是方便快捷的：它的设计初衷是用于缓存，矢量搜索，数据存储，尽管很多人把他当成消息队列，分布式锁使用，redis后面也提供了专门的事件发布和监听能力，但是估计也是不情愿的。
Redis的分布式锁
最新发布
wk200411的博客
04-12 425
分布式锁简单介绍一下
【高性能缓存Redis_中间件】一、快速上手redis缓存中间件
qq_58611691的博客
04-12 559
上述的内容从Redis 消息队列的基础概念、安装配置方法以及基本的使用模式进行了初步的讲解，redis消息队列以其高性能和简单易用的特点，在很多场景下发挥着重要作用，例如：消息确认机制、延迟队列等功能。
[Redis]redis-windows下载安装与使用
啾啾头号大粉丝打工买粮博客
04-09 634
本篇记录windows redis下载安装与使用。
Redis安装与使用RedisDesktop数据查看教程
- 由于Redis具有速度快、支持多种数据结构等特性，它可以用于缓存系统（如Memcached的替代）、会话存储、消息队列系统、排行榜/实时计数、社交网络功能（如点赞、关注）等多种场景。 ### RedisDesktop知识点： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值