职贝云数AI新零售门户

标题: Redis完成微博好友功能微服务（关注，取关，共同关注） [打印本页]
作者: ymuUw7L16pYA    时间: 2023-1-4 00:18
标题: Redis完成微博好友功能微服务（关注，取关，共同关注）
需求分析

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

(, 下载次数: 1)
相似于这样的功能我们假如采用数据库做的话只是单纯得到用户的一些粉丝或者关注列表的话是很简单也很容易完成, 但是假如我想要查出两个甚至少个用户共同关注了哪些人或者想要查询两个或者多个用户的共同粉丝的话就会很费事, 效率也不会很高。但是假如你用redis去做的话就会相当的简单而且效率很高。缘由是redis本人本身带有专门针对于这种集合的交集、并集、差集的一些操作。

(, 下载次数: 1)
设计思绪

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

这个数据库表的结构比较简单，次要记录了用户id、用户关注的id和关注形态。
  1. CREATE TABLE `t_follow` (
  2.   `id` int(11) NOT NULL AUTO_INCREMENT,
  3.   `user_id` int(11) DEFAULT NULL COMMENT '当前登录用户的id',
  4.   `follow_user_id` int(11) DEFAULT NULL COMMENT '当前登录用户关注的用户的id',
  5.   `is_valid` tinyint(1) DEFAULT NULL COMMENT '关注形态，0-没有关注，1-关注了',
  6.   `create_date` datetime DEFAULT NULL,
  7.   `update_date` datetime DEFAULT NULL,
  8.   PRIMARY KEY (`id`)
  9. ) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT COMMENT='用户和用户关注表';
复制代码
新建好友功能微服务

添加依赖和配置

pom依赖如下：
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>redis-seckill</artifactId>
  7.         <groupId>com.zjq</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>ms-follow</artifactId>
  14.     <dependencies>
  15.         <!-- eureka client -->
  16.         <dependency>
  17.             <groupId>org.springframework.cloud</groupId>
  18.             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  19.         </dependency>
  20.         <!-- spring web -->
  21.         <dependency>
  22.             <groupId>org.springframework.boot</groupId>
  23.             <artifactId>spring-boot-starter-web</artifactId>
  24.         </dependency>
  25.         <!-- mysql -->
  26.         <dependency>
  27.             <groupId>mysql</groupId>
  28.             <artifactId>mysql-connector-java</artifactId>
  29.         </dependency>
  30.         <!-- spring data redis -->
  31.         <dependency>
  32.             <groupId>org.springframework.boot</groupId>
  33.             <artifactId>spring-boot-starter-data-redis</artifactId>
  34.         </dependency>
  35.         <!-- mybatis -->
  36.         <dependency>
  37.             <groupId>org.mybatis.spring.boot</groupId>
  38.             <artifactId>mybatis-spring-boot-starter</artifactId>
  39.         </dependency>
  40.         <!-- commons 公共项目 -->
  41.         <dependency>
  42.             <groupId>com.zjq</groupId>
  43.             <artifactId>commons</artifactId>
  44.             <version>1.0-SNAPSHOT</version>
  45.         </dependency>
  46.         <!-- swagger -->
  47.         <dependency>
  48.             <groupId>com.battcn</groupId>
  49.             <artifactId>swagger-spring-boot-starter</artifactId>
  50.         </dependency>
  51.     </dependencies>
  53. </project>
复制代码
springboot配置如下：
  1. server:
  2.   port: 7004 # 端口
  4. spring:
  5.   application:
  6.     name: ms-follow # 运用名
  7.   # 数据库
  8.   datasource:
  9.     driver-class-name: com.mysql.cj.jdbc.Driver
  10.     username: root
  11.     password: root
  12.     url: jdbc:mysql://127.0.0.1:3306/seckill?serverTimezone=Asia/Shanghai&characterEncoding=utf8&useUnicode=true&useSSL=false
  13.   # Redis
  14.   redis:
  15.     port: 6379
  16.     host: localhost
  17.     timeout: 3000
  18.     password: 123456
  19.     database: 2
  20.   # Swagger
  21.   swagger:
  22.     base-package: com.zjq.follow
  23.     title: 好用功能微服务API接口文档
  25. # 配置 Eureka Server 注册中心
  26. eureka:
  27.   instance:
  28.     prefer-ip-address: true
  29.     instance-id: ${spring.cloud.client.ip-address}:${server.port}
  30.   client:
  31.     service-url:
  32.       defaultZone: http://localhost:7000/eureka/
  34. service:
  35.   name:
  36.     ms-oauth-server: http://ms-oauth2-server/
  37.     ms-diners-server: http://ms-users/
  39. mybatis:
  40.   configuration:
  41.     map-underscore-to-camel-case: true # 开启驼峰映射
  43. logging:
  44.   pattern:
  45.     console: '%d{HH:mm:ss} [%thread] %-5level %logger{50} - %msg%n'
复制代码
添加配置类

redis配置类：
  1. package com.zjq.seckill.config;
  3. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  4. import com.fasterxml.jackson.annotation.PropertyAccessor;
  5. import com.fasterxml.jackson.databind.ObjectMapper;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8. import org.springframework.core.io.ClassPathResource;
  9. import org.springframework.data.redis.connection.RedisConnectionFactory;
  10. import org.springframework.data.redis.core.RedisTemplate;
  11. import org.springframework.data.redis.core.script.DefaultRedisScript;
  12. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  13. import org.springframework.data.redis.serializer.StringRedisSerializer;
  15. /**
  16. * RedisTemplate配置类
  17. * @author zjq
  18. */
  19. @Configuration
  20. public class RedisTemplateConfiguration {
  22.     /**
  23.      * redisTemplate 序列化运用的jdkSerializeable, 存储二进制字节码, 所以自定义序列化类
  24.      *
  25.      * @param redisConnectionFactory
  26.      * @return
  27.      */
  28.     @Bean
  29.     public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
  30.         RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
  31.         redisTemplate.setConnectionFactory(redisConnectionFactory);
  33.         // 运用Jackson2JsonRedisSerialize 交换默许序列化
  34.         Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  36.         ObjectMapper objectMapper = new ObjectMapper();
  37.         objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  38.         jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
  40.         // 设置key和value的序列化规则
  41.         redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
  42.         redisTemplate.setKeySerializer(new StringRedisSerializer());
  44.         redisTemplate.setHashKeySerializer(new StringRedisSerializer());
  45.         redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
  47.         redisTemplate.afterPropertiesSet();
  48.         return redisTemplate;
  49.     }
  50.    
  52. }
复制代码
REST配置类：

(, 下载次数: 1)
关注/取关完成

业务逻辑


(, 下载次数: 1)
Mapper完成

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

(, 下载次数: 1)
Service层完成
  1. package com.zjq.seckill.service;
  3. import cn.hutool.core.bean.BeanUtil;
  4. import com.zjq.commons.constant.ApiConstant;
  5. import com.zjq.commons.constant.RedisKeyConstant;
  6. import com.zjq.commons.exception.ParameterException;
  7. import com.zjq.commons.model.domain.ResultInfo;
  8. import com.zjq.commons.model.pojo.Follow;
  9. import com.zjq.commons.model.vo.SignInUserInfo;
  10. import com.zjq.commons.utils.AssertUtil;
  11. import com.zjq.commons.utils.ResultInfoUtil;
  12. import com.zjq.seckill.mapper.FollowMapper;
  13. import org.springframework.beans.factory.annotation.Value;
  14. import org.springframework.data.redis.core.RedisTemplate;
  15. import org.springframework.stereotype.Service;
  16. import org.springframework.web.client.RestTemplate;
  18. import javax.annotation.Resource;
  19. import java.util.LinkedHashMap;
  21. /**
  22. * 关注/取关业务逻辑层
  23. * @author zjq
  24. */
  25. @Service
  26. public class FollowService {
  28.     @Value("${service.name.ms-oauth-server}")
  29.     private String oauthServerName;
  30.     @Value("${service.name.ms-diners-server}")
  31.     private String dinersServerName;
  32.     @Resource
  33.     private RestTemplate restTemplate;
  34.     @Resource
  35.     private FollowMapper followMapper;
  36.     @Resource
  37.     private RedisTemplate redisTemplate;
  40.     /**
  41.      * 关注/取关
  42.      *
  43.      * @param followUserId 关注的食客ID
  44.      * @param isFollowed    能否关注 1=关注 0=取关
  45.      * @param accessToken   登录用户token
  46.      * @param path          访问地址
  47.      * @return
  48.      */
  49.     public ResultInfo follow(Integer followUserId, int isFollowed,
  50.                              String accessToken, String path) {
  51.         // 能否选择了关注对象
  52.         AssertUtil.isTrue(followUserId == null || followUserId < 1,
  53.                 "请选择要关注的人");
  54.         // 获取登录用户信息 (封装方法)
  55.         SignInUserInfo dinerInfo = loadSignInDinerInfo(accessToken);
  56.         // 获取当前登录用户与需求关注用户的关注信息
  57.         Follow follow = followMapper.selectFollow(dinerInfo.getId(), followUserId);
  59.         // 假如没有关注信息，且要停止关注操作 -- 添加关注
  60.         if (follow == null && isFollowed == 1) {
  61.             // 添加关注信息
  62.             int count = followMapper.save(dinerInfo.getId(), followUserId);
  63.             // 添加关注列表到 Redis
  64.             if (count == 1) {
  65.                 addToRedisSet(dinerInfo.getId(), followUserId);
  66.             }
  67.             return ResultInfoUtil.build(ApiConstant.SUCCESS_CODE,
  68.                     "关注成功", path, "关注成功");
  69.         }
  71.         // 假如有关注信息，且目前处于关注形态，且要停止取关操作 -- 取关关注
  72.         if (follow != null && follow.getIsValid() == 1 && isFollowed == 0) {
  73.             // 取关
  74.             int count = followMapper.update(follow.getId(), isFollowed);
  75.             // 移除 Redis 关注列表
  76.             if (count == 1) {
  77.                 removeFromRedisSet(dinerInfo.getId(), followUserId);
  78.             }
  79.             return ResultInfoUtil.build(ApiConstant.SUCCESS_CODE,
  80.                     "成功取关", path, "成功取关");
  81.         }
  83.         // 假如有关注信息，且目前处于取关形态，且要停止关注操作 -- 重新关注
  84.         if (follow != null && follow.getIsValid() == 0 && isFollowed == 1) {
  85.             // 重新关注
  86.             int count = followMapper.update(follow.getId(), isFollowed);
  87.             // 添加关注列表到 Redis
  88.             if (count == 1) {
  89.                 addToRedisSet(dinerInfo.getId(), followUserId);
  90.             }
  91.             return ResultInfoUtil.build(ApiConstant.SUCCESS_CODE,
  92.                     "关注成功", path, "关注成功");
  93.         }
  95.         return ResultInfoUtil.buildSuccess(path, "操作成功");
  96.     }
  98.     /**
  99.      * 添加关注列表到 Redis
  100.      *
  101.      * @param dinerId
  102.      * @param followUserId
  103.      */
  104.     private void addToRedisSet(Integer dinerId, Integer followUserId) {
  105.         redisTemplate.opsForSet().add(RedisKeyConstant.following.getKey() + dinerId, followUserId);
  106.         redisTemplate.opsForSet().add(RedisKeyConstant.followers.getKey() + followUserId, dinerId);
  107.     }
  109.     /**
  110.      * 移除 Redis 关注列表
  111.      *
  112.      * @param dinerId
  113.      * @param followUserId
  114.      */
  115.     private void removeFromRedisSet(Integer dinerId, Integer followUserId) {
  116.         redisTemplate.opsForSet().remove(RedisKeyConstant.following.getKey() + dinerId, followUserId);
  117.         redisTemplate.opsForSet().remove(RedisKeyConstant.followers.getKey() + followUserId, dinerId);
  118.     }
  120.     /**
  121.      * 获取登录用户信息
  122.      *
  123.      * @param accessToken
  124.      * @return
  125.      */
  126.     private SignInUserInfo loadSignInDinerInfo(String accessToken) {
  127.         // 必须登录
  128.         AssertUtil.mustLogin(accessToken);
  129.         String url = oauthServerName + "user/me?access_token={accessToken}";
  130.         ResultInfo resultInfo = restTemplate.getForObject(url, ResultInfo.class, accessToken);
  131.         if (resultInfo.getCode() != ApiConstant.SUCCESS_CODE) {
  132.             throw new ParameterException(resultInfo.getMessage());
  133.         }
  134.         SignInUserInfo dinerInfo = BeanUtil.fillBeanWithMap((LinkedHashMap) resultInfo.getData(),
  135.                 new SignInUserInfo(), false);
  136.         return dinerInfo;
  137.     }
  139. }
复制代码
Controller完成
  1. package com.zjq.seckill.controller;
  4. import com.zjq.commons.model.domain.ResultInfo;
  5. import com.zjq.seckill.service.FollowService;
  6. import org.springframework.web.bind.annotation.*;
  8. import javax.annotation.Resource;
  9. import javax.servlet.http.HttpServletRequest;
  11. /**
  12. * 关注/取关控制层
  13. * @author zjq
  14. */
  15. @RestController
  16. public class FollowController {
  18.     @Resource
  19.     private FollowService followService;
  20.     @Resource
  21.     private HttpServletRequest request;
  23.     /**
  24.      * 关注/取关
  25.      *
  26.      * @param followUserId 关注的用户ID
  27.      * @param isFollowed    能否关注 1=关注 0=取消
  28.      * @param access_token  登录用户token
  29.      * @return
  30.      */
  31.     @PostMapping("/{followUserId}")
  32.     public ResultInfo follow(@PathVariable Integer followUserId,
  33.                              @RequestParam int isFollowed,
  34.                              String access_token) {
  35.         ResultInfo resultInfo = followService.follow(followUserId,
  36.                 isFollowed, access_token, request.getServletPath());
  37.         return resultInfo;
  38.     }
  40. }
复制代码
网关配置路由规则
  1. spring:
  2.   application:
  3.     name: ms-gateway
  4.   cloud:
  5.     gateway:
  6.       discovery:
  7.         locator:
  8.           enabled: true # 开启配置注册中心停止路由功能
  9.           lower-case-service-id: true # 将服务称号转小写
  10.       routes:
  11.          
  12.          # 好友功能微服务
  13.         - id: ms-follow
  14.           uri: lb://ms-follow
  15.           predicates:
  16.             - Path=/follow/**
  17.           filters:
  18.             - StripPrefix=1
复制代码
测实验证

依次启动，注册中心、网关、认证中心、好友功能微服务。
测试id为5的用户，关注id为1的用户。

(, 下载次数: 1)
查看redis可以看到有两个集合，一个粉丝集合，一个关注集合。

(, 下载次数: 1)
查看数据库，id为5的用户关注了id为1的用户

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

(, 下载次数: 1)
共同关注列表

Controller添加方法
  1.     /**
  2.      * 共同关注列表
  3.      *
  4.      * @param userId
  5.      * @param access_token
  6.      * @return
  7.      */
  8.     @GetMapping("commons/{userId}")
  9.     public ResultInfo findCommonsFriends(@PathVariable Integer userId,
  10.                                          String access_token) {
  11.         return followService.findCommonsFriends(userId, access_token, request.getServletPath());
  12.     }
复制代码
Service添加方法
  1.     /**
  2.      * 共同关注列表
  3.      *
  4.      * @param userId
  5.      * @param accessToken
  6.      * @param path
  7.      * @return
  8.      */
  9.     @Transactional(rollbackFor = Exception.class)
  10.     public ResultInfo findCommonsFriends(Integer userId, String accessToken, String path) {
  11.         // 能否选择了查看对象
  12.         AssertUtil.isTrue(userId == null || userId < 1,
  13.                 "请选择要查看的人");
  14.         // 获取登录用户信息
  15.         SignInUserInfo userInfo = loadSignInuserInfo(accessToken);
  16.         // 获取登录用户的关注信息
  17.         String loginuserKey = RedisKeyConstant.following.getKey() + userInfo.getId();
  18.         // 获取登录用户查看对象的关注信息
  19.         String userKey = RedisKeyConstant.following.getKey() + userId;
  20.         // 计算交集
  21.         Set<Integer> userIds = redisTemplate.opsForSet().intersect(loginuserKey, userKey);
  22.         // 没有
  23.         if (userIds == null || userIds.isEmpty()) {
  24.             return ResultInfoUtil.buildSuccess(path, new ArrayList<ShortUserInfo>());
  25.         }
  26.         // 调用食客服务根据 ids 查询食客信息
  27.         ResultInfo resultInfo = restTemplate.getForObject(usersServerName + "findByIds?access_token={accessToken}&ids={ids}",
  28.                 ResultInfo.class, accessToken, StrUtil.join(",", userIds));
  29.         if (resultInfo.getCode() != ApiConstant.SUCCESS_CODE) {
  30.             resultInfo.setPath(path);
  31.             return resultInfo;
  32.         }
  33.         // 处理结果集
  34.         List<LinkedHashMap> dinnerInfoMaps = (ArrayList) resultInfo.getData();
  35.         List<ShortUserInfo> userInfos = dinnerInfoMaps.stream()
  36.                 .map(user -> BeanUtil.fillBeanWithMap(user, new ShortUserInfo(), true))
  37.                 .collect(Collectors.toList());
  39.         return ResultInfoUtil.buildSuccess(path, userInfos);
  40.     }
复制代码
用户服务新增根据ids查询用户集合

Controller:
  1.     /**
  2.      * 根据 ids 查询用户信息
  3.      *
  4.      * @param ids
  5.      * @return
  6.      */
  7.     @GetMapping("findByIds")
  8.     public ResultInfo<List<ShortUserInfo>> findByIds(String ids) {
  9.         List<ShortUserInfo> dinerInfos = userService.findByIds(ids);
  10.         return ResultInfoUtil.buildSuccess(request.getServletPath(), dinerInfos);
  11.     }
复制代码
Service：
  1.     /**
  2.      * 根据 ids 查询食客信息
  3.      *
  4.      * @param ids 主键 id，多个以逗号分隔，逗号之间不用空格
  5.      * @return
  6.      */
  7.     public List<ShortUserInfo> findByIds(String ids) {
  8.         AssertUtil.isNotEmpty(ids);
  9.         String[] idArr = ids.split(",");
  10.         List<ShortUserInfo> dinerInfos = usersMapper.findByIds(idArr);
  11.         return dinerInfos;
  12.     }
复制代码
Mapper:
  1.     /**
  2.      * 根据 ID 集合查询多个食客信息
  3.      * @param ids
  4.      * @return
  5.      */
  6.     @Select("<script> " +
  7.             " select id, nickname, avatar_url from t_diners " +
  8.             " where is_valid = 1 and id in " +
  9.             " <foreach item=\"id\" collection=\"ids\" open=\"(\" separator=\",\" close=\")\"> " +
  10.             "   #{id} " +
  11.             " </foreach> " +
  12.             " </script>")
  13.     List<ShortUserInfo> findByIds(@Param("ids") String[] ids);
复制代码
下面测试曾经让id5和7的用户关注了id为1的用户，我们继续让id5的用户关注id为3的用户，让id5、6、7的用户关注了id为2的用户：
redis和数据库信息如下：

(, 下载次数: 1)

(, 下载次数: 1)

(, 下载次数: 1)

(, 下载次数: 1)
测实验证

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

(, 下载次数: 1)
查询当前登录用户id为6和id为7的共同关注信息：

(, 下载次数: 1)
可以看出来5和7共同关注了1和2，6和7只共同关注了2，符合预期。
本文内容到此结束了
如有播种欢迎点赞
您的鼓励是我最大的动力
如有错误❌疑问 欢迎各位指出




欢迎光临 职贝云数AI新零售门户 (https://www.taojin168.com/cloud/) Powered by Discuz! X3.5