Redis实现微博好友功能微服务（关注，取关，共同关注）

最新推荐文章于 2024-07-24 09:39:18 发布
最新推荐文章于 2024-07-24 09:39:18 发布
阅读量497 收藏 3
点赞数
文章标签： redis 微服务 数据库 java 缓存
原文链接：https://mp.weixin.qq.com/s?__biz=MzIwMTY0NDU3Nw==&mid=2651962300&idx=1&sn=6229aa95e73e9cfc80b271b5684d6336&chksm=8d0fd4f2ba785de49bc514c44a842991e2203ee944da770d396c919b76849a3ea801bc589410&scene=126&&sessionid=0
版权

需求分析

好友功能是目前社交场景的必备功能之一，一般好友相关的功能包含有：关注/取关、我（他）的关注、我（他）的粉丝、共同关注、我关注的人也关注他等这样一些功能。

6ceab9ae097ba59f67a52dde9b839775.png

类似于这样的功能我们如果采用数据库做的话只是单纯得到用户的一些粉丝或者关注列表的话是很简单也很容易实现, 但是如果我想要查出两个甚至多个用户共同关注了哪些人或者想要查询两个或者多个用户的共同粉丝的话就会很麻烦, 效率也不会很高。但是如果你用redis去做的话就会相当的简单而且效率很高。原因是redis自己本身带有专门针对于这种集合的交集、并集、差集的一些操作。

4f831fe00e3cb9a795e08752c3a4d69b.png

设计思路

总体思路我们采用MySQL + Redis的方式结合完成。MySQL主要是保存落地数据，而利用Redis的Sets数据类型进行集合操作。Sets拥有去重(我们不能多次关注同一用户)功能。一个用户我们存贮两个集合：一个是保存用户关注的人 另一个是保存关注用户的人。

  • SADD 添加成员；命令格式: SADD key member [member …] ----- 关注

  • SREM 移除某个成员；命令格式: SREM key member [member …] -------取关

  • SCARD 统计集合内的成员数；命令格式: SCARD key -------关注/粉丝个数

  • SISMEMBER 判断是否是集合成员；命令格式:SISMEMBER key member ---------判断是否关注（如果关注那么只可以点击取关）

  • SMEMBERS 查询集合内的成员；命令格式: SMEMBERS key -------列表使用（关注列表和粉丝列表）

  • SINTER 查询集合的交集；命令格式: SINTER key [key …] --------共同关注、我关注的人关注了他

  • 需要开通正版IDEA的可以联系我，79元一年，正版授权，官网可查有效期，有需要的加我微信：poxiaozhiai6，备注：126。

数据库表设计

这个数据库表的结构比较简单，主要记录了用户id、用户关注的id和关注状态。

CREATE TABLE `t_follow` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `user_id` int(11) DEFAULT NULL COMMENT '当前登录用户的id',
  `follow_user_id` int(11) DEFAULT NULL COMMENT '当前登录用户关注的用户的id',
  `is_valid` tinyint(1) DEFAULT NULL COMMENT '关注状态，0-没有关注，1-关注了',
  `create_date` datetime DEFAULT NULL,
  `update_date` datetime DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT COMMENT='用户和用户关注表';

新建好友功能微服务

添加依赖和配置

pom依赖如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>redis-seckill</artifactId>
        <groupId>com.zjq</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>ms-follow</artifactId>

    <dependencies>
        <!-- eureka client -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!-- spring web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!-- spring data redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <!-- commons 公共项目 -->
        <dependency>
            <groupId>com.zjq</groupId>
            <artifactId>commons</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!-- swagger -->
        <dependency>
            <groupId>com.battcn</groupId>
            <artifactId>swagger-spring-boot-starter</artifactId>
        </dependency>
    </dependencies>

</project>

springboot配置如下：

server:
  port: 7004 # 端口

spring:
  application:
    name: ms-follow # 应用名
  # 数据库
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: root
    url: jdbc:mysql://127.0.0.1:3306/seckill?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useUnicode=true&useSSL=false
  # Redis
  redis:
    port: 6379
    host: localhost
    timeout: 3000
    password: 123456
    database: 2
  # Swagger
  swagger:
    base-package: com.zjq.follow
    title: 好用功能微服务API接口文档

# 配置 Eureka Server 注册中心
eureka:
  instance:
    prefer-ip-address: true
    instance-id: ${spring.cloud.client.ip-address}:${server.port}
  client:
    service-url:
      defaultZone: http://localhost:7000/eureka/

service:
  name:
    ms-oauth-server: http://ms-oauth2-server/
    ms-diners-server: http://ms-users/

mybatis:
  configuration:
    map-underscore-to-camel-case: true # 开启驼峰映射

logging:
  pattern:
    console: '%d{HH:mm:ss} [%thread] %-5level %logger{50} - %msg%n'

添加配置类

redis配置类：

package com.zjq.seckill.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * RedisTemplate配置类
 * @author zjq
 */
@Configuration
public class RedisTemplateConfiguration {

    /**
     * redisTemplate 序列化使用的jdkSerializeable, 存储二进制字节码, 所以自定义序列化类
     *
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        // 使用Jackson2JsonRedisSerialize 替换默认序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        // 设置key和value的序列化规则
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setKeySerializer(new StringRedisSerializer());

        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
    

}

REST配置类：

18f797974b6b697cb5ce0b85dc5569fb.png

关注/取关实现

业务逻辑

5fc45d6e1396b13e1c1a9b8a42db178f.png

Mapper实现

Mapper比较简单主要是查询关注信息、添加关注信息、取关或者再次关注。

b5def55bf421080cc9f417a03dc6779e.png

Service层实现

package com.zjq.seckill.service;

import cn.hutool.core.bean.BeanUtil;
import com.zjq.commons.constant.ApiConstant;
import com.zjq.commons.constant.RedisKeyConstant;
import com.zjq.commons.exception.ParameterException;
import com.zjq.commons.model.domain.ResultInfo;
import com.zjq.commons.model.pojo.Follow;
import com.zjq.commons.model.vo.SignInUserInfo;
import com.zjq.commons.utils.AssertUtil;
import com.zjq.commons.utils.ResultInfoUtil;
import com.zjq.seckill.mapper.FollowMapper;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.util.LinkedHashMap;

/**
 * 关注/取关业务逻辑层
 * @author zjq
 */
@Service
public class FollowService {

    @Value("${service.name.ms-oauth-server}")
    private String oauthServerName;
    @Value("${service.name.ms-diners-server}")
    private String dinersServerName;
    @Resource
    private RestTemplate restTemplate;
    @Resource
    private FollowMapper followMapper;
    @Resource
    private RedisTemplate redisTemplate;


    /**
     * 关注/取关
     *
     * @param followUserId 关注的食客ID
     * @param isFollowed    是否关注 1=关注 0=取关
     * @param accessToken   登录用户token
     * @param path          访问地址
     * @return
     */
    public ResultInfo follow(Integer followUserId, int isFollowed,
                             String accessToken, String path) {
        // 是否选择了关注对象
        AssertUtil.isTrue(followUserId == null || followUserId < 1,
                "请选择要关注的人");
        // 获取登录用户信息 (封装方法)
        SignInUserInfo dinerInfo = loadSignInDinerInfo(accessToken);
        // 获取当前登录用户与需要关注用户的关注信息
        Follow follow = followMapper.selectFollow(dinerInfo.getId(), followUserId);

        // 如果没有关注信息，且要进行关注操作 -- 添加关注
        if (follow == null && isFollowed == 1) {
            // 添加关注信息
            int count = followMapper.save(dinerInfo.getId(), followUserId);
            // 添加关注列表到 Redis
            if (count == 1) {
                addToRedisSet(dinerInfo.getId(), followUserId);
            }
            return ResultInfoUtil.build(ApiConstant.SUCCESS_CODE,
                    "关注成功", path, "关注成功");
        }

        // 如果有关注信息，且目前处于关注状态，且要进行取关操作 -- 取关关注
        if (follow != null && follow.getIsValid() == 1 && isFollowed == 0) {
            // 取关
            int count = followMapper.update(follow.getId(), isFollowed);
            // 移除 Redis 关注列表
            if (count == 1) {
                removeFromRedisSet(dinerInfo.getId(), followUserId);
            }
            return ResultInfoUtil.build(ApiConstant.SUCCESS_CODE,
                    "成功取关", path, "成功取关");
        }

        // 如果有关注信息，且目前处于取关状态，且要进行关注操作 -- 重新关注
        if (follow != null && follow.getIsValid() == 0 && isFollowed == 1) {
            // 重新关注
            int count = followMapper.update(follow.getId(), isFollowed);
            // 添加关注列表到 Redis
            if (count == 1) {
                addToRedisSet(dinerInfo.getId(), followUserId);
            }
            return ResultInfoUtil.build(ApiConstant.SUCCESS_CODE,
                    "关注成功", path, "关注成功");
        }

        return ResultInfoUtil.buildSuccess(path, "操作成功");
    }

    /**
     * 添加关注列表到 Redis
     *
     * @param dinerId
     * @param followUserId
     */
    private void addToRedisSet(Integer dinerId, Integer followUserId) {
        redisTemplate.opsForSet().add(RedisKeyConstant.following.getKey() + dinerId, followUserId);
        redisTemplate.opsForSet().add(RedisKeyConstant.followers.getKey() + followUserId, dinerId);
    }

    /**
     * 移除 Redis 关注列表
     *
     * @param dinerId
     * @param followUserId
     */
    private void removeFromRedisSet(Integer dinerId, Integer followUserId) {
        redisTemplate.opsForSet().remove(RedisKeyConstant.following.getKey() + dinerId, followUserId);
        redisTemplate.opsForSet().remove(RedisKeyConstant.followers.getKey() + followUserId, dinerId);
    }

    /**
     * 获取登录用户信息
     *
     * @param accessToken
     * @return
     */
    private SignInUserInfo loadSignInDinerInfo(String accessToken) {
        // 必须登录
        AssertUtil.mustLogin(accessToken);
        String url = oauthServerName + "user/me?access_token={accessToken}";
        ResultInfo resultInfo = restTemplate.getForObject(url, ResultInfo.class, accessToken);
        if (resultInfo.getCode() != ApiConstant.SUCCESS_CODE) {
            throw new ParameterException(resultInfo.getMessage());
        }
        SignInUserInfo dinerInfo = BeanUtil.fillBeanWithMap((LinkedHashMap) resultInfo.getData(),
                new SignInUserInfo(), false);
        return dinerInfo;
    }

}

Controller实现

package com.zjq.seckill.controller;


import com.zjq.commons.model.domain.ResultInfo;
import com.zjq.seckill.service.FollowService;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;

/**
 * 关注/取关控制层
 * @author zjq
 */
@RestController
public class FollowController {

    @Resource
    private FollowService followService;
    @Resource
    private HttpServletRequest request;

    /**
     * 关注/取关
     *
     * @param followUserId 关注的用户ID
     * @param isFollowed    是否关注 1=关注 0=取消
     * @param access_token  登录用户token
     * @return
     */
    @PostMapping("/{followUserId}")
    public ResultInfo follow(@PathVariable Integer followUserId,
                             @RequestParam int isFollowed,
                             String access_token) {
        ResultInfo resultInfo = followService.follow(followUserId,
                isFollowed, access_token, request.getServletPath());
        return resultInfo;
    }

}

网关配置路由规则

spring:
  application:
    name: ms-gateway
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true # 开启配置注册中心进行路由功能
          lower-case-service-id: true # 将服务名称转小写
      routes:
         
         # 好友功能微服务
        - id: ms-follow
          uri: lb://ms-follow
          predicates:
            - Path=/follow/**
          filters:
            - StripPrefix=1

测试验证

依次启动，注册中心、网关、认证中心、好友功能微服务。

测试id为5的用户，关注id为1的用户。

9e3309b55a24eb055782f59c24d887a1.png de07b576712ecaaf8b388e9161bad5ae.png

查看redis可以看到有两个集合，一个粉丝集合，一个关注集合。

abad5323a9328b4f671038b47ac2dd8b.png

查看数据库，id为5的用户关注了id为1的用户

6c4d29dea2130479fcab924cf4e1f0fb.png

让id等于7的用户关注id等于1的用户，redis和数据库存储信息如下：

4e261397689d14291e7e351429cafb61.png

共同关注列表

  • 从Redis中读取登录用户的关注列表与查看用户的关注列表，然后进行交集操作，获取共同关注的用户id

  • 然后通过用户服务传入用户id数据获取用户基本信息

Controller添加方法

/**
     * 共同关注列表
     *
     * @param userId
     * @param access_token
     * @return
     */
    @GetMapping("commons/{userId}")
    public ResultInfo findCommonsFriends(@PathVariable Integer userId,
                                         String access_token) {
        return followService.findCommonsFriends(userId, access_token, request.getServletPath());
    }

Service添加方法

/**
     * 共同关注列表
     *
     * @param userId
     * @param accessToken
     * @param path
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public ResultInfo findCommonsFriends(Integer userId, String accessToken, String path) {
        // 是否选择了查看对象
        AssertUtil.isTrue(userId == null || userId < 1,
                "请选择要查看的人");
        // 获取登录用户信息
        SignInUserInfo userInfo = loadSignInuserInfo(accessToken);
        // 获取登录用户的关注信息
        String loginuserKey = RedisKeyConstant.following.getKey() + userInfo.getId();
        // 获取登录用户查看对象的关注信息
        String userKey = RedisKeyConstant.following.getKey() + userId;
        // 计算交集
        Set<Integer> userIds = redisTemplate.opsForSet().intersect(loginuserKey, userKey);
        // 没有
        if (userIds == null || userIds.isEmpty()) {
            return ResultInfoUtil.buildSuccess(path, new ArrayList<ShortUserInfo>());
        }
        // 调用食客服务根据 ids 查询食客信息
        ResultInfo resultInfo = restTemplate.getForObject(usersServerName + "findByIds?access_token={accessToken}&ids={ids}",
                ResultInfo.class, accessToken, StrUtil.join(",", userIds));
        if (resultInfo.getCode() != ApiConstant.SUCCESS_CODE) {
            resultInfo.setPath(path);
            return resultInfo;
        }
        // 处理结果集
        List<LinkedHashMap> dinnerInfoMaps = (ArrayList) resultInfo.getData();
        List<ShortUserInfo> userInfos = dinnerInfoMaps.stream()
                .map(user -> BeanUtil.fillBeanWithMap(user, new ShortUserInfo(), true))
                .collect(Collectors.toList());

        return ResultInfoUtil.buildSuccess(path, userInfos);
    }

用户服务新增根据ids查询用户集合

Controller:

/**
     * 根据 ids 查询用户信息
     *
     * @param ids
     * @return
     */
    @GetMapping("findByIds")
    public ResultInfo<List<ShortUserInfo>> findByIds(String ids) {
        List<ShortUserInfo> dinerInfos = userService.findByIds(ids);
        return ResultInfoUtil.buildSuccess(request.getServletPath(), dinerInfos);
    }

Service：

/**
     * 根据 ids 查询食客信息
     *
     * @param ids 主键 id，多个以逗号分隔，逗号之间不用空格
     * @return
     */
    public List<ShortUserInfo> findByIds(String ids) {
        AssertUtil.isNotEmpty(ids);
        String[] idArr = ids.split(",");
        List<ShortUserInfo> dinerInfos = usersMapper.findByIds(idArr);
        return dinerInfos;
    }

Mapper:

/**
     * 根据 ID 集合查询多个食客信息
     * @param ids
     * @return
     */
    @Select("<script> " +
            " select id, nickname, avatar_url from t_diners " +
            " where is_valid = 1 and id in " +
            " <foreach item=\"id\" collection=\"ids\" open=\"(\" separator=\",\" close=\")\"> " +
            "   #{id} " +
            " </foreach> " +
            " </script>")
    List<ShortUserInfo> findByIds(@Param("ids") String[] ids);

上面测试已经让id5和7的用户关注了id为1的用户，我们继续让id5的用户关注id为3的用户，让id5、6、7的用户关注了id为2的用户：

redis和数据库信息如下：

c47be8dac0b34ab978267f44f75d662c.png e5044c4420da2c0c6cf98a613095563f.png c9232e581af09bcf18aad87b786de181.png 362109b0ac2a70e729a758bd80922cc3.png

测试验证

查询当前登录用户id为5和id为7的共同关注信息：

ecdcb27c08d55993da0198a51ab1b3af.png

查询当前登录用户id为6和id为7的共同关注信息：

54d5c2e7ec75f9231bb99889ab3d6d51.png

可以看出来5和7共同关注了1和2，6和7只共同关注了2，符合预期。

本文内容到此结束了
如有收获欢迎点赞👍
您的鼓励是我最大的动力
如有错误❌疑问💬欢迎各位指出

作者：共饮一杯无

来源：https://zhanjq.blog.csdn.net/?type=blog

Java团长在csdn
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
redis笔记
m0_46177001的博客
07-27 961
以无序的方式存储多个不同的元素【无序，不重复】，除了对集合能快速执行添加，删除，检查元素是否存在之外，还可以对多个集合执行交集，并集，差集的操作，set集合类型底层的数据结构是。list就是链表，在redis中List使用双端链表来实现，结构是有序的value值可以重复，可以通过下标取出对应value值，左右两边都能进行插入和删除数据。Spring-data-redis提供了客户端的抽象，在开发中可以忽略具体的客户端的操作带来的影响，其本身就是spring生态的一部分，比起jedis更加方便。...
用Redis实现微博关注关系
09-10
本文将探讨如何利用Redis这一高性能的键值存储系统来实现微博的关注和粉丝关系的高效处理。 首先，我们需要理解四种关注关系状态：关注、粉丝、双向关注（互粉）以及无关系。对于每个用户，Redis中会维护两个集合，...
实战：第二十一章：实现微博微信关注模型
Java程序员廖志伟
06-08 502
业务实现层： @Override public ResultData<RelationshipUsersAndFansDto> getRelationshipUsersAndFans(String userId, String followId) { List<B8UserUserinfoEntity> myself = userinfoMapper.getRelationshipUsersAndFans(userId); List&l
【Redis】Redis入门教程(介绍 下载安装 Jedis 图形化界面)
专注于Java领域开发 关注我 带你玩转Java
08-10 1168
想在短时间内学习Redis 不妨看看这篇文章
【分布式框架-Redis】
恁爹的博客
03-04 2014
跟恁爹学Redis
Redis总结
Java硬件工程师的博客
04-05 1432
redis版本升级说明 接下来内容概述： 安装redis6.0.8 redis传统五大数据类型的落地应用 知道分布式锁吗？有哪些实现方案？你谈谈对redis分布式锁的理解，删key的时候有什么问题? redis缓存过期淘汰策略 redis的LRU算法简介 安装redis6.0.8： Redis官网 Redis中文网 安全Bug按照官网提示，升级成为6.0.8 进入Redis命令行，输入info，返回关于Redis服务器的各种信息（包括版本号）和统计数值。 redis两个小细节说明 redis基本类型
redis学习归纳
m566666的博客
10-23 1376
Redis是什么？Redis（Remote Dictionary Server )，即远程字典服务!Nosql数据库是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。redis会周期性的把更新的数据写入磁盘或者把修改操作（全量和增量）写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。免费和开源！是当下最热门的 NoSQL 技术之一！也被人们称之为结构化数据库！Redis能干嘛？
Redis从入门到精通【redis基础】
qq_55317476的博客
06-28 627
​ 这个Redis的初心，最初就是用来作为一个“消息中间件”的（消息队列），作为一种分布式系统下的生产者消费者模型。但是当前很少人会直接使用Redis作为消息中间件了（因为业界有更多更专业的消息中间件使用）单机架构（应用程序+数据库服务器）数据库和应用分离应用程序和数据库服务器，分别放到了不同主机上部署了引入负载均衡优化应用服务器 => 集群通过负载均衡器，把请求比较均匀的分发给集群中的每个应用服务器，并且当集群中的某个主机挂了，其他主机仍然可以承担服务，提高了整个系统的可用性。
Redis五种数据结构及其使用场景
m0_38041658的博客
05-04 3452
Redis五种数据结构及其使用场景
redis面试
天才小熊猫的客栈
07-03 477
redis传统五大数据类型的落地应用？ String(字符类型) Hash(散列类型) List(列表类型) Set(集合) SortedSet(有序集合类型，简称zset) Bitmap(位图) HyperLogLog(统计) GEO(地理) 备注： redis的命令不区分大小写，而key区分大小写 help@类型名词 应用： 1.string 2.hash 3.list 4.set set 不可重复，无序 （1）微信...
redis+php实现微博（二）发布与关注功能详解
10-16
主要介绍了redis+php实现微博发布与关注功能,结合实例形式分析了php结合redis实现微博的发布及关注相关操作技巧,需要的朋友可以参考下
PHP+redis实现微博的推模型案例分析
01-02
本文实例讲述了PHP+redis实现微博的推模型。分享给大家供大家参考，具体如下： 最近在看了一下关于redis的内容，然后利用redis写了一个简单的微博项目，这篇文章是关于推模型的。 推模型 所谓推模型，就是用户在发布...
【Redis】主从复制分析-基础
LCN29的博客
07-22 765
对于 Redis 从节点, 可能因为版本问题, 存在着复制能力不一致的情况, 所以在主从复制开始的阶段, 从节点需要将自身支持的复制能力发送给主节点,(这个缓存区是一个环形的数组, 从头写到尾, 写满了, 重新回到头, 继续写, 新的数据覆盖掉旧的, 同时所有的从节点共用一个缓冲区)。在运行中, 主节点处理完了命令, 会遍历自身维护的所有的从节点, 将自身执行的命令发送给所有状态符合的从节点, 保证数据的一致。主从建立了连接, 主节点会将自身所有的数据生成为一个 RDB 的文件, 然后以。
Redis 哨兵搭建
qq_36838700的博客
07-23 903
操作系统Centos 7内核版本主机名称masterIP端口。
redis常用指令
m0_62289159的博客
07-22 864
redis常用指令
分布式缓存与Redis
最新发布
modelsetget的博客
07-24 590
为读者提供对分布式缓存和Redis的深入理解
Redis小结
weixin_63566388的博客
07-22 683
Redis 是一个开源的、基于内存的数据结构存储系统，可以用作数据库、缓存和消息中间件。它支持多种数据结构，如字符串、哈希、列表、集合、有序集合等。
Redis在SpringBoot中配置
qq_64669006的博客
07-23 365
由于redis的序列化方式如果不合适，会导致传入的数据在redis库里是乱码的形式存在，一般使用Jackson2JsonRedisSerializer作为redis的序列化方式。redis的使用方法有两种，jedis和lecttuce，jedis用的不是很多，下面讲解用lettuce的使用方法。配置就完成了，接下来可以使用redis了。序列化object对象为json字符串。可以将任何对象泛化为字符串并序列化。添加ip地址和redis的端口号。这是redis的配置类。
微博与微信朋友关注模型基于redis实现
05-11
将用户的关注关系存储在Redis中，可以方便地进行查询和更新，进而实现微博和微信的朋友关注模型。 总之，微博和微信的朋友关注模型基于Redis实现是一种非常优秀的选择。它保证了系统的性能、可扩展性和高可用性，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值