课程说明

  • 首页功能说明
  • 系统架构说明
  • 实现今日佳人功能
  • 实现推荐用户的列表
  • 接口增加缓存功能
  • 整合前端联调测试

1、首页

在用户登录成功后，就会进入首页，首页中有今日佳人、推荐好友、探花、搜附近等功能。
1564104604248.png

2、系统架构

在开发完SSO系统中的登录功能后，接下来就需要实现其他的功能，在整体架构中，完成与APP对接的服务工程叫my-tanhua-server，真正的核心业务逻辑使用dubbo完成，其工程名叫：my-tanhua-dubbo，它们的架构示意图如下：
image-20201130102009217.png

说明：

  • 客户端APP发起请求到Nginx，在Nginx中对请求做出判断，将请求转发至sso系统或server系统。
  • sso系统中，将对接第三方平台以及完成数据的缓存、消息发送、用户的注册登录功能。
  • server系统为APP提供了接口服务的支撑
    • 用户请求中携带的token需要到sso系统中进行校验
    • 通过rpc调用dubbo中提供的服务，在dubbo服务中与MongoDB对接，完成数据的CRUD操作
    • 将一些数据缓存到Redis，从而提升数据查询性能
    • 用户数据的查询将基于MySQL数据库进行查询

2.1、nginx服务

2.1.1、部署安装

安装包在资料中：nginx-1.17.3.zip

安装在任意目录，通过命令：start nginx.exe 启动：
1566999483561.png

重启加载配置文件命令：nginx.exe -s reload
1566999546104.png
关掉nginx的命令：nginx -s stop

2.1.2、配置

修改conf目录下的nginx.conf文件：

  1. #user  nobody;
  2. worker_processes  1;
  4. #error_log  logs/error.log;
  5. #error_log  logs/error.log  notice;
  6. #error_log  logs/error.log  info;
  8. #pid        logs/nginx.pid;
  11. events {
  12.     worker_connections  1024;
  13. }
  16. http {
  17.     include       mime.types;
  18.     default_type  application/octet-stream;
  20.     #log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
  21.     #                  '$status $body_bytes_sent "$http_referer" '
  22.     #                  '"$http_user_agent" "$http_x_forwarded_for"';
  24.     #access_log  logs/access.log  main;
  26.     sendfile        on;
  27.     #tcp_nopush     on;
  29.     #keepalive_timeout  0;
  30.     keepalive_timeout  65;
  32.     #gzip  on;
  34.     server {
  35.         listen       80;
  36.         server_name  localhost;
  38.         #charset koi8-r;
  40.         #access_log  logs/host.access.log  main;
  42.         #error_page  404              /404.html;
  44.         # redirect server error pages to the static page /50x.html
  45.         #
  46.         error_page   500 502 503 504  /50x.html;
  47.         location = /50x.html {
  48.             root   html;
  49.         }
  51.         location /user/ {  #请求路径中凡是以/user/开头的请求，转发到sso系统
  52.             client_max_body_size  300m;  #设置最大的请求体大小，解决大文件上传不了的问题
  53.             proxy_connect_timeout 300s;  #代理连接超时时间
  54.             proxy_send_timeout 300s;  #代理发送数据的超时时间
  55.             proxy_read_timeout 300s;  #代理读取数据的超时时间
  56.             proxy_pass   http://127.0.0.1:18080;  #转发请求
  57.         }
  59.         location / {   #上面未匹配到的在这里处理
  60.             client_max_body_size  300m;
  61.             proxy_connect_timeout 300s;
  62.             proxy_send_timeout 300s;
  63.             proxy_read_timeout 300s;
  64.                 proxy_pass   http://127.0.0.1:18081;  #转发请求到server系统
  65.             }
  66.         }
  68. }

2.1.3、测试

image-20201130111356817.png

2.2、搭建server工程

2.2.1、导入依赖

pom.xml文件：

  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>my-tanhua</artifactId>
  7.         <groupId>cn.xiaoha.tanhua</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>my-tanhua-server</artifactId>
  15.     <dependencies>
  16.         <dependency>
  17.             <groupId>cn.xiaoha.tanhua</groupId>
  18.             <artifactId>my-tanhua-dubbo-interface</artifactId>
  19.             <version>1.0-SNAPSHOT</version>
  20.         </dependency>
  21.         <dependency>
  22.             <groupId>org.springframework.boot</groupId>
  23.             <artifactId>spring-boot-starter-web</artifactId>
  24.         </dependency>
  25.         <dependency>
  26.             <groupId>org.springframework.boot</groupId>
  27.             <artifactId>spring-boot-starter-test</artifactId>
  28.             <scope>test</scope>
  29.         </dependency>
  30.         <dependency>
  31.             <groupId>org.springframework.boot</groupId>
  32.             <artifactId>spring-boot-starter-data-redis</artifactId>
  33.         </dependency>
  34.         <!--dubbo的springboot支持-->
  35.         <dependency>
  36.             <groupId>com.alibaba.boot</groupId>
  37.             <artifactId>dubbo-spring-boot-starter</artifactId>
  38.         </dependency>
  39.         <!--dubbo框架-->
  40.         <dependency>
  41.             <groupId>com.alibaba</groupId>
  42.             <artifactId>dubbo</artifactId>
  43.         </dependency>
  44.         <!--zk依赖-->
  45.         <dependency>
  46.             <groupId>org.apache.zookeeper</groupId>
  47.             <artifactId>zookeeper</artifactId>
  48.         </dependency>
  49.         <dependency>
  50.             <groupId>com.github.sgroschupf</groupId>
  51.             <artifactId>zkclient</artifactId>
  52.         </dependency>
  53.         <dependency>
  54.             <groupId>org.apache.commons</groupId>
  55.             <artifactId>commons-lang3</artifactId>
  56.         </dependency>
  57.         <dependency>
  58.             <groupId>org.apache.commons</groupId>
  59.             <artifactId>commons-collections4</artifactId>
  60.             <version>4.4</version>
  61.         </dependency>
  62.         <dependency>
  63.             <groupId>com.baomidou</groupId>
  64.             <artifactId>mybatis-plus</artifactId>
  65.         </dependency>
  66.         <dependency>
  67.             <groupId>com.baomidou</groupId>
  68.             <artifactId>mybatis-plus-boot-starter</artifactId>
  69.         </dependency>
  70.         <dependency>
  71.             <groupId>mysql</groupId>
  72.             <artifactId>mysql-connector-java</artifactId>
  73.         </dependency>
  74.         <dependency>
  75.             <groupId>commons-io</groupId>
  76.             <artifactId>commons-io</artifactId>
  77.             <version>2.6</version>
  78.         </dependency>
  79.         <dependency>
  80.             <groupId>commons-codec</groupId>
  81.             <artifactId>commons-codec</artifactId>
  82.         </dependency>
  83.         <dependency>
  84.             <groupId>com.alibaba.spring</groupId>
  85.             <artifactId>spring-context-support</artifactId>
  86.             <version>1.0.2</version>
  87.         </dependency>
  88.     </dependencies>
  90. </project>

2.2.2、application.properties

  1. spring.application.name = itcast-tanhua-server
  2. server.port = 18081
  4. #数据库连接信息
  5. spring.datasource.driver-class-name=com.mysql.jdbc.Driver
  6. spring.datasource.url=jdbc:mysql://192.168.31.81:3306/mytanhua?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&useSSL=false
  7. spring.datasource.username=root
  8. spring.datasource.password=root
  10. # 枚举包扫描
  11. mybatis-plus.type-enums-package=com.tanhua.server.enums
  12. # 表名前缀（mybatis-plus）
  13. mybatis-plus.global-config.db-config.table-prefix=tb_
  14. # id策略为自增长（mybatis-plus）
  15. mybatis-plus.global-config.db-config.id-type=auto
  17. #dubbo注册中心配置
  18. dubbo.application.name = itcast-tanhua-server
  19. dubbo.registry.address = zookeeper://192.168.31.81:2181
  20. dubbo.registry.client = zkclient
  21. dubbo.registry.timeout = 60000
  22. dubbo.consumer.timeout = 60000
  24. #开启缓存服务
  25. tanhua.cache.enable=false
  27. # Redis相关配置
  28. spring.redis.jedis.pool.max-wait = 5000ms
  29. spring.redis.jedis.pool.max-Idle = 100
  30. spring.redis.jedis.pool.min-Idle = 10
  31. spring.redis.timeout = 10s
  32. spring.redis.cluster.nodes = 192.168.31.81:6379,192.168.31.81:6380,192.168.31.81:6381
  33. spring.redis.cluster.max-redirects=5
  35. #sso系统服务地址
  36. tanhua.sso.url=http://127.0.0.1
  37. #默认今日佳人推荐用户
  38. tanhua.sso.default.user=2

2.2.3、ServerApplication

  1. package com.tanhua.server;
  3. import org.mybatis.spring.annotation.MapperScan;
  4. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;
  7. @MapperScan("com.tanhua.server.mapper") //设置mapper接口的扫描包
  8. @SpringBootApplication
  9. public class ServerApplication {
  11.     public static void main(String[] args) {
  12.         SpringApplication.run(ServerApplication.class, args);
  13.     }
  14. }

2.3、搭建dubbo工程

my-tanhua-dubbo是dubbo工程的父工程：

  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>my-tanhua</artifactId>
  7.         <groupId>cn.xiaoha.tanhua</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>my-tanhua-dubbo</artifactId>
  14.     <packaging>pom</packaging>
  15.     <modules>
  16.         <module>my-tanhua-dubbo-interface</module>
  17.         <module>my-tanhua-dubbo-service</module>
  18.     </modules>
  20. </project>

2.3.1、创建my-tanhua-dubbo-interface工程

该工程中定义了dubbo服务中的interface与实体对象。

  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>my-tanhua-dubbo</artifactId>
  7.         <groupId>cn.xiaoha.tanhua</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>my-tanhua-dubbo-interface</artifactId>
  14.     <dependencies>
  15.         <dependency>
  16.             <groupId>org.projectlombok</groupId>
  17.             <artifactId>lombok</artifactId>
  18.         </dependency>
  19.         <dependency>
  20.             <groupId>org.springframework.boot</groupId>
  21.             <artifactId>spring-boot-starter-data-mongodb</artifactId>
  22.         </dependency>
  23.     </dependencies>
  24. </project>

2.3.2、创建my-tanhua-dubbo-service工程

  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>my-tanhua-dubbo</artifactId>
  7.         <groupId>cn.xiaoha.tanhua</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>my-tanhua-dubbo-service</artifactId>
  14.     <dependencies>
  15.         <!--引入interface依赖-->
  16.         <dependency>
  17.             <groupId>cn.xiaoha.tanhua</groupId>
  18.             <artifactId>my-tanhua-dubbo-interface</artifactId>
  19.             <version>1.0-SNAPSHOT</version>
  20.         </dependency>
  21.         <dependency>
  22.             <groupId>org.springframework.boot</groupId>
  23.             <artifactId>spring-boot-starter</artifactId>
  24.         </dependency>
  25.         <dependency>
  26.             <groupId>org.springframework.boot</groupId>
  27.             <artifactId>spring-boot-starter-test</artifactId>
  28.             <scope>test</scope>
  29.         </dependency>
  31.         <!--dubbo的springboot支持-->
  32.         <dependency>
  33.             <groupId>com.alibaba.boot</groupId>
  34.             <artifactId>dubbo-spring-boot-starter</artifactId>
  35.         </dependency>
  36.         <!--dubbo框架-->
  37.         <dependency>
  38.             <groupId>com.alibaba</groupId>
  39.             <artifactId>dubbo</artifactId>
  40.         </dependency>
  41.         <dependency>
  42.             <groupId>com.alibaba.spring</groupId>
  43.             <artifactId>spring-context-support</artifactId>
  44.             <version>1.0.2</version>
  45.         </dependency>
  46.         <!--zk依赖-->
  47.         <dependency>
  48.             <groupId>org.apache.zookeeper</groupId>
  49.             <artifactId>zookeeper</artifactId>
  50.         </dependency>
  51.         <dependency>
  52.             <groupId>com.github.sgroschupf</groupId>
  53.             <artifactId>zkclient</artifactId>
  54.         </dependency>
  56.         <!--MongoDB相关依赖-->
  57.      <dependency>
  58.             <groupId>org.springframework.boot</groupId>
  59.             <artifactId>spring-boot-starter-data-mongodb</artifactId>
  60.         </dependency>
  62.         <dependency>
  63.             <groupId>org.mongodb</groupId>
  64.             <artifactId>mongodb-driver-sync</artifactId>
  65.         </dependency>
  67.         <!--其他工具包依赖-->
  68.         <dependency>
  69.             <groupId>org.apache.commons</groupId>
  70.             <artifactId>commons-lang3</artifactId>
  71.         </dependency>
  72.         <dependency>
  73.             <groupId>joda-time</groupId>
  74.             <artifactId>joda-time</artifactId>
  75.         </dependency>
  77.         <dependency>
  78.             <groupId>io.netty</groupId>
  79.             <artifactId>netty-all</artifactId>
  80.         </dependency>
  81.     </dependencies>
  83. </project>

dubbo-service中的application.properties：

  1. # Spring boot application
  2. spring.application.name = xiaoha-tanhua-dubbo-service
  4. # dubbo 扫描包配置
  5. dubbo.scan.basePackages = com.tanhua.dubbo.server
  6. dubbo.application.name = dubbo-provider-tanhua
  8. #dubbo 对外暴露的端口信息
  9. dubbo.protocol.name = dubbo
  10. dubbo.protocol.port = 20880
  12. #dubbo注册中心的配置
  13. dubbo.registry.address = zookeeper://192.168.31.81:2181
  14. dubbo.registry.client = zkclient
  15. dubbo.registry.timeout = 60000 
  16. dubbo.provider.host= 192.168.31.1
  18. #springboot MongoDB配置
  19. spring.data.mongodb.username=tanhua
  20. spring.data.mongodb.password=l3SCjl0HvmSkTtiSbN0Swv40spYnHhDV
  21. spring.data.mongodb.authentication-database=admin
  22. spring.data.mongodb.database=tanhua
  23. spring.data.mongodb.port=27017
  24. spring.data.mongodb.host=192.168.31.81

编写启动类：

  1. package com.tanhua.dubbo.server;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. @SpringBootApplication
  7. public class DubboApplication {
  9.     public static void main(String[] args) {
  10.         SpringApplication.run(DubboApplication.class, args);
  11.     }
  12. }

2.4、工程结构

最终搭建完成的效果如下：
image-20201130120238951.png

3、今日佳人

今日佳人，会推荐缘分值最大的用户，进行展现出来。缘分值的计算是由用户的行为进行打分，如：点击、点赞、评论、学历、婚姻状态等信息组合而成的。

实现：我们先不考虑推荐的逻辑，假设现在已经有推荐的结果，我们只需要从结果中查询到缘分值最高的用户就可以了。至于推荐的逻辑以及实现，我们将后面的课程中讲解。

流程：
image-20201130150720621.png

3.1、表结构

  1. #表结构，表名：recommend_user
  2. {
  3.   "userId":1001,  #推荐的用户id
  4.   "toUserId":1002, #用户id
  5.   "score":90,  #推荐得分
  6.   "date":"2019/1/1" #日期
  7. }

已经提供的测试数据（4855条数据）：
image-20201130151126971.png

3.2、编写dubbo服务

3.2.1、编写接口

在my-tanhua-dubbo-interface工程中定义接口：

  1. package com.tanhua.dubbo.server.api;
  3. import com.tanhua.dubbo.server.pojo.RecommendUser;
  4. import com.tanhua.dubbo.server.vo.PageInfo;
  6. public interface RecommendUserApi {
  7.     /**
  8.      * 查询一位得分
  9.      * 最高的推荐用户
  10.      *
  11.      * @param userId 推荐用户的id
  12.      * @return 封装表数据的映射实体类
  13.      */
  14.     RecommendUser queryWithMaxScore(Long userId);
  16.     /**
  17.      * 按照得分倒序
  18.      *
  19.      * @param userId  推荐用户的id
  20.      * @param pageNum 当前页数
  21.      * @param pageSize 当前页所显示的数据条数
  22.      * @return  封装分页查询的结果类
  23.      */
  24.     PageInfo<RecommendUser> queryPageInfo(Long userId, Integer pageNum, Integer pageSize);
  25. }
  1. package com.tanhua.dubbo.server.pojo;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  6. import org.bson.types.ObjectId;
  7. import org.springframework.data.annotation.Id;
  8. import org.springframework.data.mongodb.core.index.Indexed;
  9. import org.springframework.data.mongodb.core.mapping.Document;
  11. import java.io.Serializable;
  13. @Data //生成javabean类set、get等方法的注解
  14. @NoArgsConstructor  //生成无参构造方法的注解
  15. @AllArgsConstructor //生成全参构造方法的注解
  16. @Document(collection = "recommend_user") //指定MongoDB的表
  17. public class RecommendUser implements Serializable {
  18.     //该类实现serializable接口便于序列化通过流传输
  19.     //设置序列化的id号；
  20.     private static final long serialVersionUID = -4296017160071130962L;
  22.     @Id
  23.     private ObjectId id; //主键id
  24.     @Indexed
  25.     private Long userId; //推荐的用户id
  26.     private Long toUserId; //用户id
  27.     @Indexed
  28.     private Double score; //推荐得分
  29.     private String date; //日期
  30. }
  1. package com.tanhua.dubbo.server.vo;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  6. import java.io.Serializable;
  7. import java.util.Collections;
  8. import java.util.List;
  10. @Data
  11. @AllArgsConstructor
  12. public class PageInfo<T> implements Serializable {
  13.     //该类实现serializable接口便于序列化通过流传输
  14.     //设置序列化的id号；
  15.     private static final long serialVersionUID = -2105385689859184204L;
  17.     /**
  18.      * 总条数
  19.      */
  20.     private Integer total = 0;
  22.     /**
  23.      * 当前页
  24.      */
  25.     private Integer pageNum = 0;
  27.     /**
  28.      * 一页显示的大小
  29.      */
  30.     private Integer pageSize = 0;
  32.     /**
  33.      * 数据列表
  34.      */
  35.     private List<T> records = Collections.emptyList();
  36. }

3.2.2、编写实现

  1. package com.tanhua.dubbo.server.api;
  3. import com.alibaba.dubbo.config.annotation.Service;
  4. import com.tanhua.dubbo.server.pojo.RecommendUser;
  5. import com.tanhua.dubbo.server.vo.PageInfo;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.data.domain.PageRequest;
  8. import org.springframework.data.domain.Sort;
  9. import org.springframework.data.mongodb.core.MongoTemplate;
  10. import org.springframework.data.mongodb.core.query.Criteria;
  11. import org.springframework.data.mongodb.core.query.Query;
  13. import java.util.List;
  15. @Service(version = "1.0.0") //指定该类是一个dubbo服务
  16. public class RecommendUserApiImpl implements RecommendUserApi {
  17.     //注入MongoDB的模本类
  18.     @Autowired
  19.     private MongoTemplate mongoTemplate;
  21.     /**
  22.      * 查询单个最高分数
  23.      * 的被推荐用户
  24.      * @param userId 被推荐用户的id
  25.      * @return
  26.      */
  27.     @Override
  28.     public RecommendUser queryWithMaxScore(Long userId) {
  29.         //查询条件方法，
  30.         // 通过用户id（toUserId）作为条件，
  31.         //查询被推荐用户的id（userId）
  32.         //查询条件相当于where toUserId = userId
  33.         Query queryTemp = Query.query(Criteria
  34.                 .where("toUserId")
  35.                 .is(userId));
  37.         // 然后再根据分数降序排序
  38.         Query query = queryTemp.with(Sort.by(Sort.Order.desc("score"))).limit(1);
  39.         //mongoTemplate提供的查询一个数据的方法
  40.         //参数一为查询条件，参数二为返回指定类的
  41.         // 字节码对象
  42.         RecommendUser one = this.mongoTemplate.findOne(query, RecommendUser.class);
  43.         return one;
  44.     }
  46.     @Override
  47.     public PageInfo<RecommendUser> queryPageInfo(Long userId, Integer pageNum, Integer pageSize) {
  48.         //进行分页处理
  49.         PageRequest page = PageRequest.of(pageNum - 1,
  50.                                             pageSize,
  51.                                             Sort.by(Sort.Order.desc("score")));
  52.         //查询条件方法，
  53.         // 通过用户id（toUserId）作为条件，
  54.         //查询被推荐用户的id（userId）
  55.         Query queryTemp = Query.query(Criteria.where("toUserId").is(userId));
  56.         Query query = queryTemp.with(page);
  57.         //mongoTemplate提供的查询一个数据的方法
  58.         //参数一为查询条件，参数二为返回指定类的
  59.         // 字节码对象
  60.         List<RecommendUser> pageInfos = this.mongoTemplate.find(query, RecommendUser.class);
  61.         return new PageInfo(0,pageNum,pageSize,pageInfos);
  64.     }
  65. }

3.2.3、测试

注意：如果在测试时出现以下错误，将采取下面的措施。错误笔记.png

  1. package com.tanhua.dubbo.server.api;
  3. import org.junit.Test;
  4. import org.junit.runner.RunWith;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.boot.test.context.SpringBootTest;
  7. import org.springframework.test.context.junit4.SpringRunner;
  9. @RunWith(SpringRunner.class)
  10. @SpringBootTest
  11. public class RecommendUserApiTest {
  12.     @Autowired
  13.     private RecommendUserApi recommendUserApi;
  15.     @Test
  16.     public void findOneTest(){
  17.         System.out.println("结果一："+this.recommendUserApi.queryWithMaxScore(1L));
  18.         System.out.println("结果二："+this.recommendUserApi.queryWithMaxScore(8L));
  19.         System.out.println("结果三："+this.recommendUserApi.queryWithMaxScore(26L));
  20.     }
  22.     @Test
  23.     public void findPageTest(){
  24.         System.out.println(this.recommendUserApi.queryPageInfo(1L, 1, 5));
  25.     }
  26. }

3.3、实现今日佳人服务

3.3.1、mock服务

地址：https://mock-java.itheima.net/project/35/interface/api/617
image-20201130152808705.png1566915288334.png

3.3.2、基础代码

3.3.2.1、SexEnum
  1. package com.tanhua.server.enums;
  3. import com.baomidou.mybatisplus.core.enums.IEnum;
  5. public enum SexEnum implements IEnum<Integer> {
  7.     MAN(1,"男"),
  8.     WOMAN(2,"女"),
  9.     UNKNOWN(3,"未知");
  11.     private int value;
  12.     private String desc;
  14.     SexEnum(int value, String desc) {
  15.         this.value = value;
  16.         this.desc = desc;
  17.     }
  19.     @Override
  20.     public Integer getValue() {
  21.         return this.value;
  22.     }
  24.     @Override
  25.     public String toString() {
  26.         return this.desc;
  27.     }
  28. }

3.3.2.2、BasePojo
  1. package com.tanhua.server.pojo;
  3. import com.baomidou.mybatisplus.annotation.FieldFill;
  4. import com.baomidou.mybatisplus.annotation.TableField;
  6. import java.util.Date;
  9. public abstract class BasePojo {
  11.     @TableField(fill = FieldFill.INSERT)
  12.     private Date created;
  13.     @TableField(fill = FieldFill.INSERT_UPDATE)
  14.     private Date updated;
  15. }

3.3.2.3、User
  1. package com.tanhua.server.pojo;
  3. import com.fasterxml.jackson.annotation.JsonIgnore;
  4. import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
  5. import lombok.AllArgsConstructor;
  6. import lombok.Data;
  7. import lombok.NoArgsConstructor;
  9. @Data
  10. @NoArgsConstructor
  11. @AllArgsConstructor
  12. @JsonIgnoreProperties(ignoreUnknown = true)
  13. public class User extends BasePojo {
  15.     private Long id;
  16.     private String mobile; //手机号
  18.     @JsonIgnore
  19.     private String password; //密码，json序列化时忽略
  21. }

3.3.2.4、UserInfo
  1. package com.tanhua.server.pojo;
  3. import com.tanhua.server.enums.SexEnum;
  4. import lombok.AllArgsConstructor;
  5. import lombok.Data;
  6. import lombok.NoArgsConstructor;
  8. @Data
  9. @NoArgsConstructor
  10. @AllArgsConstructor
  11. public class UserInfo extends BasePojo {
  13.     private Long id;
  14.     private Long userId; //用户id
  15.     private String nickName; //昵称
  16.     private String logo; //用户头像
  17.     private String tags; //用户标签：多个用逗号分隔
  18.     private SexEnum sex; //性别
  19.     private Integer age; //年龄
  20.     private String edu; //学历
  21.     private String city; //城市
  22.     private String birthday; //生日
  23.     private String coverPic; // 封面图片
  24.     private String industry; //行业
  25.     private String income; //收入
  26.     private String marriage; //婚姻状态
  28. }

3.3.3、实现功能

实现描述：

  • 需要根据前端定义的结构定义java对象
  • 根据sso系统提供的接口查询当前登录用户的信息
  • 根据dubbo系统提供的服务进行查询今日佳人数据

3.3.3.1、TodayBest
  1. package com.tanhua.server.vo;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  7. /**
  8.  * 返回数据结果的封装类
  9.  * 今日佳人
  10.  */
  11. @Data
  12. @NoArgsConstructor
  13. @AllArgsConstructor
  14. public class TodayBest {
  16.     private Long id;
  17.     private String avatar; //头像
  18.     private String nickname; //昵称
  19.     private String gender; //性别 man woman
  20.     private Integer age; //年龄
  21.     private String[] tags; //标签
  22.     private Long fateValue; //缘分值
  24. }

3.3.3.2、TodayBestController
  1. package com.tanhua.server.controller;
  3. import com.tanhua.server.service.TodayBestService;
  4. import com.tanhua.server.utils.Cache;
  5. import com.tanhua.server.vo.PageResult;
  6. import com.tanhua.server.vo.RecommendUserQueryParam;
  7. import com.tanhua.server.vo.TodayBest;
  9. import lombok.extern.slf4j.Slf4j;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.http.HttpStatus;
  12. import org.springframework.http.ResponseEntity;
  13. import org.springframework.web.bind.annotation.GetMapping;
  14. import org.springframework.web.bind.annotation.RequestHeader;
  15. import org.springframework.web.bind.annotation.RequestMapping;
  16. import org.springframework.web.bind.annotation.RestController;
  18. /**
  19.  *  该类为今日佳人功能模块的
  20.  *  Controller层结构
  21.  */
  23. @RestController
  24. @RequestMapping("tanhua")
  25. @Slf4j  //打印日志的标签
  26. public class TodayBestController {
  27.     //注入service层
  28.     @Autowired
  29.     private TodayBestService todayBestService;
  31.     /**
  32.      *  接收用户传来
  33.      *  的token的方法
  34.      *
  35.      * @param token 用户传来的token
  36.      * @return 返回今日佳人的信息数据
  37.      */
  38.     @GetMapping("todayBest")
  39.     public ResponseEntity<TodayBest> queryTodayBest(@RequestHeader("Authorization")
  40.                                                                 String token){
  41.         try {
  42.             //调用service层将token传递过去
  43.             TodayBest todayBest= this.todayBestService.queryTodayBest(token);
  44.             //判断todayBest
  45.             if(null!=todayBest){
  46.                 //如果结果不为空，直接返回数据结果
  47.                 return ResponseEntity.ok(todayBest);
  48.             }
  49.         } catch (Exception e) {
  50.             //e.printStackTrace();
  51.             log.error("查询出错，",token,e);
  52.         }
  53.         //如果为空则返回空
  54.         return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
  55.     }
  57.     /**
  58.      * 推荐列表功能模块
  59.      *
  60.      * @param token 传过来的token
  61.      * @param queryParam 请求参数封装类对象
  62.      * @return 查询出来的推荐用户列表数据
  63.      */
  64.     @GetMapping("recommendation")
  65.     @Cache
  66.     public ResponseEntity<PageResult> queryRecommendation(@RequestHeader("Authorization") String token ,
  67.                                                           RecommendUserQueryParam queryParam){
  68.         try {
  69.             //调用今日佳人模块的service层，将token和请求参数传过去
  70.             //返回pageResult
  71.             PageResult pageResult = this.todayBestService.queryRecommendation(token,queryParam);
  72.             //判断
  73.             if(pageResult!=null){
  74.                 //如果结果不为空则，直接返回成功的数据
  75.                 return ResponseEntity.ok(pageResult);
  76.             }
  77.         } catch (Exception e) {
  78.             //e.printStackTrace();
  79.             log.error("查询推荐用户列表出错~ token = " + token, e);
  80.         }
  81.         return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
  82.     }
  83. }

3.3.3.3、TodayBestService
  1. package com.tanhua.server.service;
  3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  4. import com.tanhua.dubbo.server.pojo.RecommendUser;
  5. import com.tanhua.dubbo.server.vo.PageInfo;
  6. import com.tanhua.server.pojo.User;
  7. import com.tanhua.server.pojo.UserInfo;
  8. import com.tanhua.server.vo.PageResult;
  9. import com.tanhua.server.vo.RecommendUserQueryParam;
  10. import com.tanhua.server.vo.TodayBest;
  11. import org.apache.commons.lang3.StringUtils;
  12. import org.springframework.beans.factory.annotation.Autowired;
  13. import org.springframework.beans.factory.annotation.Value;
  14. import org.springframework.stereotype.Service;
  16. import java.util.*;
  18. /**
  19.  * 该类为今日佳人
  20.  * 功能模块的service层结构
  21.  */
  22. @Service
  23. public class TodayBestService {
  24.     //注入UserService，为了校验token
  25.     @Autowired
  26.     private UserService userService;
  27.     //注入查询推荐用户业务层
  28.     @Autowired
  29.     private RecommendUserService recommendUserService;
  30.     //从配置文件重货获取默认用户的id
  31.     @Value("${tanhua.sso.default.user}")
  32.     private Long defaultUser;
  33.     //注入查询用户详细信息的service
  34.     @Autowired
  35.     private  UserInfoService userInfoService;
  37.     public TodayBest queryTodayBest(String token) {
  38.         //调用userService层将token传递过去进行校验
  39.         //返回user
  40.         User user = this.userService.checkToken(token);
  41.         //判断user
  42.         if(null==user){
  43.             return null;
  44.         }
  45.         //如果不为空，就查询推荐用户
  46.         //将用户id传过去，返回推荐用户信息(去MongoDB里查数据)
  47.         TodayBest todayBest = this.recommendUserService.queryTodayBest(user.getId());
  48.         //判断结果
  49.         if(todayBest==null){
  50.             //如果为空的话，就给默认用户返回
  51.             todayBest = new TodayBest();
  52.             //将配置文件中默认的今日佳人的id封装到todayBest
  53.             todayBest.setId(defaultUser);
  54.             //设置缘分值，固定的，写死的
  55.             todayBest.setFateValue(85L);
  56.         }
  57.         //然后补全推荐用户的信息（去数据库中查）
  58.         //通过调用查询用户详细信息的service
  59.         //将推荐用户的id传递过去，返回userinfo信息
  60.         UserInfo userInfo  = this.userInfoService.queryUserInfoByUserId(todayBest.getId());
  61.         //判断返回结果
  62.         if(userInfo==null){
  63.             //为空直接返回空
  64.             return null;
  65.         }
  67.         //不为空 userinfo的数据封装到todayBest中
  68.         todayBest.setAge(userInfo.getAge());
  69.         todayBest.setNickname(userInfo.getNickName());
  70.         //todayBest.setGender(userInfo.getSex().name().toLowerCase());
  71.         todayBest.setGender(userInfo.getSex().getValue() == 1 ? "man" : "woman");
  72.         todayBest.setAvatar(userInfo.getLogo());
  73.         todayBest.setTags(StringUtils.split(userInfo.getTags(),","));
  74.         //如果不为空
  75.         return  todayBest;
  76.     }
  78.     /**
  79.      * 推荐列表的service层业务实现层方法
  80.      * @param token token
  81.      * @param queryParam 请求参数
  82.      * @return 查询结果
  83.      */
  84.     public PageResult queryRecommendation(String token, RecommendUserQueryParam queryParam) {
  85.         //调用userService校验token
  86.         User user = this.userService.checkToken(token);
  87.         //判断user
  88.         if(user == null){
  89.             //为空则返回null
  90.             return null;
  91.         }
  92.         //创建默认的返回值
  93.         PageResult pageResult = new PageResult();
  94.         pageResult.setPage(queryParam.getPage());
  95.         pageResult.setPagesize(queryParam.getPagesize());
  96.         //如果不为空，就调用recommendUserService，
  97.         // 去mongodb里查询推荐用户列表
  98.         PageInfo<RecommendUser> pageInfo =this.recommendUserService.queryRecommendUserList(
  99.                                                 user.getId(),
  100.                                                 queryParam.getPage(),
  101.                                                 queryParam.getPagesize()
  102.         );
  103.         //获取里面的用户数据
  104.         List<RecommendUser> records = pageInfo.getRecords();
  105.         //判断records
  106.         if(records==null){
  107.             //如果为空则返回默认的PageResult
  108.             return pageResult;
  109.         }
  111.         //如果不为空则 补全从mongodb查出来的用户列表信息
  112.         //创建map集合存储推荐用户的id，和缘分值
  113.         Map<Long,Long>idAndScore = new HashMap<>();
  114.         for (RecommendUser record : records) {
  115.             Double floor = Math.floor(record.getScore());
  116.             long score = floor.longValue();
  117.             idAndScore.put(record.getUserId(),score);
  118.         }
  119.         //创建查询条件
  120.         QueryWrapper<UserInfo> wrapper = new QueryWrapper<>();
  121.         //设置id集查询条件
  122.         wrapper.in("user_id",idAndScore.keySet());
  123.         //设置性别查询条件
  124.         //判断请求参数
  125.         if(StringUtils.isNotEmpty(queryParam.getGender())){
  126.             //如果用户传过来的请求参数中的性别不为空
  127.             //则再次判断请求参数中的性别
  128.             wrapper.eq("sex",StringUtils.equals(queryParam.getGender(),"man")?1:2);
  129.         }
  130.         //设置城市参数查询
  131.         if(StringUtils.isNotEmpty(queryParam.getCity())){
  132.             wrapper.like("city",queryParam.getCity());
  133.         }
  134.         //设置年龄查询条件
  135.         if(queryParam.getAge()!=null){
  136.             wrapper.le("age",queryParam.getAge());
  137.         }
  138.         List<UserInfo> userInfos = this.userInfoService.queryUserInfoList(wrapper);
  139.         //判断userInfos
  140.         if(userInfos==null){
  141.             return pageResult;
  142.         }
  143.         //如果不为空，则封装数据
  144.         List<TodayBest> result = new ArrayList<>();
  145.         //遍历userInfos,将userInfos添加到result中
  146.         for (UserInfo userInfo : userInfos) {
  147.             TodayBest best = new TodayBest();
  148.             best.setId(userInfo.getUserId());
  149.             best.setAvatar(userInfo.getLogo());
  150.             best.setNickname(userInfo.getNickName());
  151.             best.setTags(StringUtils.split(userInfo.getTags(),","));
  152.             best.setGender(userInfo.getSex().getValue() == 1 ? "man" : "woman");
  153.             best.setAge(userInfo.getAge());
  154.             //设置缘分值
  155.             for (Long id : idAndScore.keySet()) {
  156.                 //判断id
  157.                 if(id==userInfo.getUserId()){
  158.                     Long score = idAndScore.get(id);
  159.                     best.setFateValue(score);
  160.                     break;
  161.                 }
  162.             }
  163.             result.add(best);
  164.         }
  165.         //根据缘分值降序排序
  166.         Collections.sort(result, (o1, o2) -> new Long(o2.getFateValue() - o1.getFateValue()).intValue());
  167.         pageResult.setItems(result);
  168.         return pageResult;
  169.     }
  170. }

3.3.3.4、UserService
  1. package com.tanhua.server.service;
  3. import com.tanhua.server.pojo.User;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.beans.factory.annotation.Value;
  7. import org.springframework.stereotype.Service;
  8. import org.springframework.web.client.RestClientException;
  9. import org.springframework.web.client.RestTemplate;
  11. /**
  12.  * 该类为校验用户token的
  13.  * 业务层（service层）
  14.  */
  15. @Service
  16. @Slf4j
  17. public class UserService {
  18.     //注入发送rest请求的模板类
  19.     @Autowired
  20.     private  RestTemplate restTemplate;
  22.     //读取配置文件中sso的访问路径
  23.     @Value("${tanhua.sso.url}")
  24.     private String ssoUrl;
  26.     /**
  27.      * 校验用户token的方法
  28.      * @param token 用户传过来的token
  29.      * @return 用户基本信息
  30.      */
  31.     public User checkToken(String token) {
  32.         try {
  33.             //定义访问sso的路径
  34.             String url = ssoUrl+"/user/"+token;
  35.             User user = restTemplate.getForObject(url, User.class);
  36.             //判断
  37.             if(null==user){
  38.                 //如果为空直接返回null
  39.                 return  null;
  40.             }
  41.             //如果不为空则将user返回
  42.             return user;
  43.         } catch (RestClientException e) {
  44.             //e.printStackTrace();
  45.             log.error("校验token出错，token = " + token, e);
  46.         }
  47.         return null;
  48.     }
  49. }
  1. package com.tanhua.server.config;
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.http.client.ClientHttpRequestFactory;
  6. import org.springframework.http.client.SimpleClientHttpRequestFactory;
  7. import org.springframework.http.converter.StringHttpMessageConverter;
  8. import org.springframework.web.client.RestTemplate;
  10. import java.nio.charset.Charset;
  12. /**
  13.  * 该类为创建restTemplate对象的配置类
  14.  */
  15. @Configuration
  16. public class RestTemplateConfig {
  19.     @Bean
  20.     public RestTemplate restTemplate(ClientHttpRequestFactory factory) {
  21.         RestTemplate restTemplate = new RestTemplate(factory);
  22.         // 支持中文编码
  23.         restTemplate.getMessageConverters().set(1, new StringHttpMessageConverter(Charset.forName("UTF-8")));
  24.         return restTemplate;
  25.     }
  27.     @Bean
  28.     public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
  29.         SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
  30.         factory.setReadTimeout(5000);//单位为ms
  31.         factory.setConnectTimeout(5000);//单位为ms
  32.         return factory;
  33.     }
  34. }

3.3.3.5、RecommendUserService
  1. package com.tanhua.server.service;
  4. import com.alibaba.dubbo.config.annotation.Reference;
  5. import com.tanhua.dubbo.server.api.RecommendUserApi;
  6. import com.tanhua.dubbo.server.pojo.RecommendUser;
  7. import com.tanhua.dubbo.server.vo.PageInfo;
  8. import com.tanhua.server.vo.TodayBest;
  9. import org.springframework.stereotype.Service;
  11. /**
  12.  * 该类为查询MongoDB获取推荐用户的service层
  13.  */
  14. @Service
  15. public class RecommendUserService {
  16.     //注入dubbo的recommendUserService
  17.     @Reference(version = "1.0.0")
  18.     private RecommendUserApi userApi;
  20.     /**
  21.      * 从MongoDB查询推荐用户的方法
  22.      * 主要目的是将推荐用户的id和
  23.      * 缘分值拿到
  24.      *
  25.      * @param id 用户id
  26.      * @return 推荐的用户信息
  27.      */
  28.     public TodayBest queryTodayBest(Long id) {
  29.         //调用查询单个数据的方法
  30.         RecommendUser recommendUser = this.userApi.queryWithMaxScore(id);
  31.         if(recommendUser==null){
  32.             return null;
  33.         }
  34.         //如果不为空则正常返回todayBest
  35.         TodayBest todayBest = new TodayBest();
  36.         todayBest.setId(recommendUser.getUserId());
  38.         //从查询结果的recommendUser中获取缘分值
  39.         double scoreDou=recommendUser.getScore();
  40.         Double d = Math.floor(scoreDou);
  41.         long score = d.longValue();
  42.         todayBest.setFateValue(score);
  43.         return todayBest;
  44.     }
  46.     public PageInfo<RecommendUser> queryRecommendUserList(Long id, Integer page, Integer pagesize) {
  47.         return this.userApi.queryPageInfo(id,page,pagesize);
  48.     }
  49. }

3.3.3.6、UserInfoService
  1. package com.tanhua.server.service;
  3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  4. import com.tanhua.server.mapper.UserInfoMapper;
  5. import com.tanhua.server.pojo.UserInfo;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Service;
  9. import java.util.List;
  11. /**
  12.  * 该类为从数据库中查询用户详细信息的service
  13.  */
  14. @Service
  15. public class UserInfoService {
  16.     //注入mapper
  17.     @Autowired
  18.     private UserInfoMapper userInfoMapper;
  20.     /**
  21.      * 根据id查询数据
  22.      *
  23.      * @param id 用户id
  24.      * @return 用户详细信息
  25.      */
  26.     public UserInfo queryUserInfoByUserId(Long id) {
  27.         QueryWrapper<UserInfo> wrapper = new QueryWrapper<>();
  28.         wrapper.eq("user_id",id);
  29.         UserInfo userInfo = this.userInfoMapper.selectOne(wrapper);
  30.         return userInfo;
  31.     }
  33.     public List<UserInfo> queryUserInfoList(QueryWrapper<UserInfo> wrapper) {
  34.         return this.userInfoMapper.selectList(wrapper);
  35.     }
  36. }

3.3.3.7、UserInfoMapper
  1. package com.tanhua.server.mapper;
  3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  4. import com.tanhua.common.pojo.UserInfo;
  6. public interface UserInfoMapper extends BaseMapper<UserInfo> {
  8. }

3.3.4、测试

单元测试，测试dubbo服务：

  1. package com.tanhua.server;
  3. import com.tanhua.dubbo.server.pojo.RecommendUser;
  4. import com.tanhua.dubbo.server.vo.PageInfo;
  5. import com.tanhua.server.service.RecommendUserService;
  6. import com.tanhua.server.vo.RecommendUserQueryParam;
  7. import com.tanhua.server.vo.TodayBest;
  8. import org.junit.Test;
  9. import org.junit.runner.RunWith;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.boot.test.context.SpringBootTest;
  12. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  14. import java.util.List;
  16. /**
  17.  * 该类为测试查询今日佳人的测试类
  18.  */
  19. @SpringBootTest
  20. @RunWith(SpringJUnit4ClassRunner.class)
  21. public class TestRecommendUserApi {
  22.     @Autowired
  23.     private RecommendUserService recommendUserService;
  25.     @Test
  26.     public void findRecommendUser(){
  27.         TodayBest todayBest = this.recommendUserService.queryTodayBest(100L);
  28.         System.out.println(todayBest);
  29.     }
  31.     @Test
  32.     public void test(){
  33.         RecommendUserQueryParam recommendUserQueryParam = new RecommendUserQueryParam();
  34.         recommendUserQueryParam.setPage(1);
  35.         recommendUserQueryParam.setPagesize(100);
  36.         recommendUserQueryParam.setAge(30);
  37.         recommendUserQueryParam.setCity("北京城区");
  38.         recommendUserQueryParam.setGender("man");
  39.         PageInfo<RecommendUser> recommendUserPageInfo = this.recommendUserService.queryRecommendUserList(100l, 1, 100);
  40.         List<RecommendUser> records = recommendUserPageInfo.getRecords();
  41.         System.out.println(records);
  43.     }
  44. }

整合功能测试，需要将sso、dubbo服务启动完成后进行测试。
image-20201130170209235.png

3.3.5、解决MongoDB启动bug

在项目中，添加了mongo的依赖的话，springboot就会自动去连接本地的mongo，由于他连接不上会导致出错。
1567411076994.png

解决：

springboot中添加排除自动配置的注解

  1. package com.tanhua.server;
  3. import org.mybatis.spring.annotation.MapperScan;
  4. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. import org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration;
  7. import org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration;
  9. @MapperScan("com.tanhua.server.mapper") //设置mapper接口的扫描包
  10. @SpringBootApplication(exclude = {MongoAutoConfiguration.class, MongoDataAutoConfiguration.class}) //排除mongo的自动配置
  11. public class ServerApplication {
  13.     public static void main(String[] args) {
  14.         SpringApplication.run(ServerApplication.class, args);
  15.     }
  16. }

4、推荐列表

1567064038029.png

4.1、mock接口

地址：https://mock-java.itheima.net/project/35/interface/api/623
image-20201130181444611.png
1567064266212.png

4.2、查询参数对象

  1. package com.tanhua.server.vo;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  7. @Data
  8. @NoArgsConstructor
  9. @AllArgsConstructor
  10. public class RecommendUserQueryParam {
  12.     private Integer page = 1; //当前页数
  13.     private Integer pagesize = 10; //页尺寸
  14.     private String gender; //性别 man woman
  15.     private String lastLogin; //近期登陆时间
  16.     private Integer age; //年龄
  17.     private String city; //居住地
  18.     private String education; //学历
  19. }

4.3、结果对象

  1. package com.tanhua.server.vo;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  7. import java.util.Collections;
  8. import java.util.List;
  10. @Data
  11. @AllArgsConstructor
  12. @NoArgsConstructor
  13. public class PageResult {
  15.     private Integer counts = 0;//总记录数
  16.     private Integer pagesize = 0;//页大小
  17.     private Integer pages = 0;//总页数
  18.     private Integer page = 0;//当前页码
  19.     private List<?> items = Collections.emptyList(); //列表
  21. }

4.4、Controller

  1. package com.tanhua.server.controller;
  3. import com.tanhua.server.service.TodayBestService;
  4. import com.tanhua.server.utils.Cache;
  5. import com.tanhua.server.vo.PageResult;
  6. import com.tanhua.server.vo.RecommendUserQueryParam;
  7. import com.tanhua.server.vo.TodayBest;
  9. import lombok.extern.slf4j.Slf4j;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.http.HttpStatus;
  12. import org.springframework.http.ResponseEntity;
  13. import org.springframework.web.bind.annotation.GetMapping;
  14. import org.springframework.web.bind.annotation.RequestHeader;
  15. import org.springframework.web.bind.annotation.RequestMapping;
  16. import org.springframework.web.bind.annotation.RestController;
  18. /**
  19.  *  该类为今日佳人功能模块的
  20.  *  Controller层结构
  21.  */
  23. @RestController
  24. @RequestMapping("tanhua")
  25. @Slf4j  //打印日志的标签
  26. public class TodayBestController {
  27.     //注入service层
  28.     @Autowired
  29.     private TodayBestService todayBestService;
  31.     /**
  32.      *  接收用户传来
  33.      *  的token的方法
  34.      *
  35.      * @param token 用户传来的token
  36.      * @return 返回今日佳人的信息数据
  37.      */
  38.     @GetMapping("todayBest")
  39.     public ResponseEntity<TodayBest> queryTodayBest(@RequestHeader("Authorization")
  40.                                                                 String token){
  41.         try {
  42.             //调用service层将token传递过去
  43.             TodayBest todayBest= this.todayBestService.queryTodayBest(token);
  44.             //判断todayBest
  45.             if(null!=todayBest){
  46.                 //如果结果不为空，直接返回数据结果
  47.                 return ResponseEntity.ok(todayBest);
  48.             }
  49.         } catch (Exception e) {
  50.             //e.printStackTrace();
  51.             log.error("查询出错，",token,e);
  52.         }
  53.         //如果为空则返回空
  54.         return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
  55.     }
  57.     /**
  58.      * 推荐列表功能模块
  59.      *
  60.      * @param token 传过来的token
  61.      * @param queryParam 请求参数封装类对象
  62.      * @return 查询出来的推荐用户列表数据
  63.      */
  64.     @GetMapping("recommendation")
  65.     @Cache
  66.     public ResponseEntity<PageResult> queryRecommendation(@RequestHeader("Authorization") String token ,
  67.                                                           RecommendUserQueryParam queryParam){
  68.         try {
  69.             //调用今日佳人模块的service层，将token和请求参数传过去
  70.             //返回pageResult
  71.             PageResult pageResult = this.todayBestService.queryRecommendation(token,queryParam);
  72.             //判断
  73.             if(pageResult!=null){
  74.                 //如果结果不为空则，直接返回成功的数据
  75.                 return ResponseEntity.ok(pageResult);
  76.             }
  77.         } catch (Exception e) {
  78.             //e.printStackTrace();
  79.             log.error("查询推荐用户列表出错~ token = " + token, e);
  80.         }
  81.         return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
  82.     }
  83. }

4.5、Service

  1. package com.tanhua.server.service;
  3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  4. import com.tanhua.dubbo.server.pojo.RecommendUser;
  5. import com.tanhua.dubbo.server.vo.PageInfo;
  6. import com.tanhua.server.pojo.User;
  7. import com.tanhua.server.pojo.UserInfo;
  8. import com.tanhua.server.vo.PageResult;
  9. import com.tanhua.server.vo.RecommendUserQueryParam;
  10. import com.tanhua.server.vo.TodayBest;
  11. import org.apache.commons.lang3.StringUtils;
  12. import org.springframework.beans.factory.annotation.Autowired;
  13. import org.springframework.beans.factory.annotation.Value;
  14. import org.springframework.stereotype.Service;
  16. import java.util.*;
  18. /**
  19.  * 该类为今日佳人
  20.  * 功能模块的service层结构
  21.  */
  22. @Service
  23. public class TodayBestService {
  24.     //注入UserService，为了校验token
  25.     @Autowired
  26.     private UserService userService;
  27.     //注入查询推荐用户业务层
  28.     @Autowired
  29.     private RecommendUserService recommendUserService;
  30.     //从配置文件重货获取默认用户的id
  31.     @Value("${tanhua.sso.default.user}")
  32.     private Long defaultUser;
  33.     //注入查询用户详细信息的service
  34.     @Autowired
  35.     private  UserInfoService userInfoService;
  37.     public TodayBest queryTodayBest(String token) {
  38.         //调用userService层将token传递过去进行校验
  39.         //返回user
  40.         User user = this.userService.checkToken(token);
  41.         //判断user
  42.         if(null==user){
  43.             return null;
  44.         }
  45.         //如果不为空，就查询推荐用户
  46.         //将用户id传过去，返回推荐用户信息(去MongoDB里查数据)
  47.         TodayBest todayBest = this.recommendUserService.queryTodayBest(user.getId());
  48.         //判断结果
  49.         if(todayBest==null){
  50.             //如果为空的话，就给默认用户返回
  51.             todayBest = new TodayBest();
  52.             //将配置文件中默认的今日佳人的id封装到todayBest
  53.             todayBest.setId(defaultUser);
  54.             //设置缘分值，固定的，写死的
  55.             todayBest.setFateValue(85L);
  56.         }
  57.         //然后补全推荐用户的信息（去数据库中查）
  58.         //通过调用查询用户详细信息的service
  59.         //将推荐用户的id传递过去，返回userinfo信息
  60.         UserInfo userInfo  = this.userInfoService.queryUserInfoByUserId(todayBest.getId());
  61.         //判断返回结果
  62.         if(userInfo==null){
  63.             //为空直接返回空
  64.             return null;
  65.         }
  67.         //不为空 userinfo的数据封装到todayBest中
  68.         todayBest.setAge(userInfo.getAge());
  69.         todayBest.setNickname(userInfo.getNickName());
  70.         //todayBest.setGender(userInfo.getSex().name().toLowerCase());
  71.         todayBest.setGender(userInfo.getSex().getValue() == 1 ? "man" : "woman");
  72.         todayBest.setAvatar(userInfo.getLogo());
  73.         todayBest.setTags(StringUtils.split(userInfo.getTags(),","));
  74.         //如果不为空
  75.         return  todayBest;
  76.     }
  78.     /**
  79.      * 推荐列表的service层业务实现层方法
  80.      * @param token token
  81.      * @param queryParam 请求参数
  82.      * @return 查询结果
  83.      */
  84.     public PageResult queryRecommendation(String token, RecommendUserQueryParam queryParam) {
  85.         //调用userService校验token
  86.         User user = this.userService.checkToken(token);
  87.         //判断user
  88.         if(user == null){
  89.             //为空则返回null
  90.             return null;
  91.         }
  92.         //创建默认的返回值
  93.         PageResult pageResult = new PageResult();
  94.         pageResult.setPage(queryParam.getPage());
  95.         pageResult.setPagesize(queryParam.getPagesize());
  96.         //如果不为空，就调用recommendUserService，
  97.         // 去mongodb里查询推荐用户列表
  98.         PageInfo<RecommendUser> pageInfo =this.recommendUserService.queryRecommendUserList(
  99.                                                 user.getId(),
  100.                                                 queryParam.getPage(),
  101.                                                 queryParam.getPagesize()
  102.         );
  103.         //获取里面的用户数据
  104.         List<RecommendUser> records = pageInfo.getRecords();
  105.         //判断records
  106.         if(records==null){
  107.             //如果为空则返回默认的PageResult
  108.             return pageResult;
  109.         }
  111.         //如果不为空则 补全从mongodb查出来的用户列表信息
  112.         //创建map集合存储推荐用户的id，和缘分值
  113.         Map<Long,Long>idAndScore = new HashMap<>();
  114.         for (RecommendUser record : records) {
  115.             Double floor = Math.floor(record.getScore());
  116.             long score = floor.longValue();
  117.             idAndScore.put(record.getUserId(),score);
  118.         }
  119.         //创建查询条件
  120.         QueryWrapper<UserInfo> wrapper = new QueryWrapper<>();
  121.         //设置id集查询条件
  122.         wrapper.in("user_id",idAndScore.keySet());
  123.         //设置性别查询条件
  124.         //判断请求参数
  125.         if(StringUtils.isNotEmpty(queryParam.getGender())){
  126.             //如果用户传过来的请求参数中的性别不为空
  127.             //则再次判断请求参数中的性别
  128.             wrapper.eq("sex",StringUtils.equals(queryParam.getGender(),"man")?1:2);
  129.         }
  130.         //设置城市参数查询
  131.         if(StringUtils.isNotEmpty(queryParam.getCity())){
  132.             wrapper.like("city",queryParam.getCity());
  133.         }
  134.         //设置年龄查询条件
  135.         if(queryParam.getAge()!=null){
  136.             wrapper.le("age",queryParam.getAge());
  137.         }
  138.         List<UserInfo> userInfos = this.userInfoService.queryUserInfoList(wrapper);
  139.         //判断userInfos
  140.         if(userInfos==null){
  141.             return pageResult;
  142.         }
  143.         //如果不为空，则封装数据
  144.         List<TodayBest> result = new ArrayList<>();
  145.         //遍历userInfos,将userInfos添加到result中
  146.         for (UserInfo userInfo : userInfos) {
  147.             TodayBest best = new TodayBest();
  148.             best.setId(userInfo.getUserId());
  149.             best.setAvatar(userInfo.getLogo());
  150.             best.setNickname(userInfo.getNickName());
  151.             best.setTags(StringUtils.split(userInfo.getTags(),","));
  152.             best.setGender(userInfo.getSex().getValue() == 1 ? "man" : "woman");
  153.             best.setAge(userInfo.getAge());
  154.             //设置缘分值
  155.             for (Long id : idAndScore.keySet()) {
  156.                 //判断id
  157.                 if(id==userInfo.getUserId()){
  158.                     Long score = idAndScore.get(id);
  159.                     best.setFateValue(score);
  160.                     break;
  161.                 }
  162.             }
  163.             result.add(best);
  164.         }
  165.         //根据缘分值降序排序
  166.         Collections.sort(result, (o1, o2) -> new Long(o2.getFateValue() - o1.getFateValue()).intValue());
  167.         pageResult.setItems(result);
  168.         return pageResult;
  169.     }
  170. }
  1. //RecommendUserService
  2.     public PageInfo<RecommendUser> queryRecommendUserList(Long id, Integer page, Integer pagesize) {
  3.         return this.recommendUserApi.queryPageInfo(id, page, pagesize);
  4.     }
  1. //UserInfoService
  2.     /**
  3.      * 查询用户信息列表
  4.      *
  5.      * @param queryWrapper
  6.      * @return
  7.      */
  8.     public List<UserInfo> queryUserInfoList(QueryWrapper queryWrapper) {
  9.         return this.userInfoMapper.selectList(queryWrapper);
  10.     }

4.6、测试

image-20201130190537686.png
image-20201130190553650.png

5、缓存

在接口服务中，有必要对于接口进行缓存处理，尤其是GET请求，如果每个接口单独添加的话会存在很多的重复的逻辑，所以可以编写一套通用的解决方案。

实现思路：

  • 通过拦截器实现对请求的拦截，在拦截器中实现缓存的命中。
  • 通过ResponseBodyAdvice进行对响应的拦截，可以将数据缓存到Redis中。
  • 考虑到，不能对于所有的请求都一刀切，所以需要创建@Cache注解进行标记，只有标记的Controller才进行缓存处理。
  • 缓存的处理中，仅针对GET请求处理，其他的请求均不做处理。

5.1、自定义注解 （知识盲点：注解）

  1. package com.tanhua.server.utils;
  3. import java.lang.annotation.*;
  5. /**
  6.  * 被标记为Cache的Controller进行缓存，
  7.  * 其他情况不进行缓存
  8.  */
  9. @Target(ElementType.METHOD)
  10. @Retention(RetentionPolicy.RUNTIME)
  11. @Documented //标记注解
  12. public @interface Cache {
  13.     /**
  14.      * 缓存时间，默认为60秒
  15.      * @return
  16.      */
  17.     String time() default "60";
  18. }

5.2、采用拦截器进行缓存命中

编写拦截器：RedisCacheInterceptor。（知识盲点：HandlerInterceptor、@Component）

  1. package com.tanhua.server.interceptor;
  3. import com.fasterxml.jackson.core.JsonProcessingException;
  4. import com.fasterxml.jackson.databind.ObjectMapper;
  5. import com.tanhua.server.utils.Cache;
  6. import org.apache.commons.codec.digest.DigestUtils;
  7. import org.apache.commons.lang3.StringUtils;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.beans.factory.annotation.Value;
  10. import org.springframework.data.redis.core.RedisTemplate;
  11. import org.springframework.stereotype.Component;
  12. import org.springframework.web.bind.annotation.GetMapping;
  13. import org.springframework.web.method.HandlerMethod;
  14. import org.springframework.web.servlet.HandlerInterceptor;
  16. import javax.servlet.http.HttpServletRequest;
  17. import javax.servlet.http.HttpServletResponse;
  19. @Component
  20. public class RedisCacheInterceptor implements HandlerInterceptor {
  21.     //开启redis缓存机制的配置
  22.     @Value("${tanhua.cache.enable}")
  23.     private Boolean enable;
  24.     //redis工具类
  25.     @Autowired
  26.     private RedisTemplate<String, String> redisTemplate;
  27.     //json转换类
  28.     private static final ObjectMapper MAPPER = new ObjectMapper();
  30.     @Override
  31.     public boolean preHandle(HttpServletRequest request,
  32.                              HttpServletResponse response,
  33.                              Object handler) throws Exception {
  34.         //缓存的全局开关的校验
  35.         if (!enable) {
  36.             //为enable为true就放行
  37.             return true;
  38.         }
  40.         //校验handler是否是HandlerMethod(表示为访问controller的方法)
  41.         if (!(handler instanceof HandlerMethod)) {
  42.             //不是HandlerMethod就放行
  43.             return true;
  44.         }
  46.         //判断是否为get请求
  47.         if (!((HandlerMethod) handler).hasMethodAnnotation(GetMapping.class)) {
  48.             //不是get请求就放行
  49.             return true;
  50.         }
  52.         //判断是否添加了@Cache注解
  53.         if (!((HandlerMethod) handler).hasMethodAnnotation(Cache.class)) {
  54.             //没有加Cache注解就放行
  55.             return true;
  56.         }
  58.         //没有满足以上的判断就进行缓存命中
  59.         //缓存命中
  60.         String redisKey = createRedisKey(request);
  61.         //通过键从redis中获取值
  62.         String cacheData = this.redisTemplate.opsForValue().get(redisKey);
  63.         //判断从redis中获取到的值
  64.         if(StringUtils.isEmpty(cacheData)){
  65.             //为空则表示缓存未命中，放行
  66.             return true;
  67.         }
  69.         // 如果不为空就将redis中查出的data数据进行响应
  70.         response.setCharacterEncoding("UTF-8");
  71.         response.setContentType("application/json; charset=utf-8");
  72.         response.getWriter().write(cacheData);
  73.         return false;
  74.     }
  77.     /**
  78.      * 该类为创建redis的key的方法 规则：SERVER_CACHE_DATA_MD5(url + param + token)
  79.      * @param request servlet的请求封装类
  80.      * @return redis的key
  81.      * @throws JsonProcessingException
  82.      */
  84.     public static String createRedisKey(HttpServletRequest request) throws JsonProcessingException {
  85.         //获取url请求路径
  86.         String url = request.getRequestURI();
  87.         //通过json转换类将封装请求参数的map集合对象转换成json格式的字符串
  88.         String param = MAPPER.writeValueAsString(request.getParameterMap());
  89.         //获取token
  90.         String token = request.getHeader("Authorization");
  91.         //拼接key的规则
  92.         String data = url + "_" + param + "_" + token;
  93.         //加密并返回
  94.         return "SERVER_CACHE_DATA_" + DigestUtils.md5Hex(data);
  96.     }
  97.     /*@Value("${tanhua.cache.enable}")
  98.     private Boolean enable;
  100.     @Autowired
  101.     private RedisTemplate<String, String> redisTemplate;
  103.     private static final ObjectMapper MAPPER = new ObjectMapper();
  105.     @Override
  106.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  107.         //缓存的全局开关的校验
  108.         if (!enable) {
  109.             //为true表示放行
  110.             return true;
  111.         }
  113.         //校验handler是否是HandlerMethod(表示为访问controller的方法)
  114.         if (!(handler instanceof HandlerMethod)) {
  115.             return true;
  116.         }
  118.         //判断是否为get请求
  119.         if (!((HandlerMethod) handler).hasMethodAnnotation(GetMapping.class)) {
  120.             return true;
  121.         }
  123.         //判断是否添加了@Cache注解
  124.         if (!((HandlerMethod) handler).hasMethodAnnotation(Cache.class)) {
  125.             return true;
  126.         }
  128.         //缓存命中
  129.         String redisKey = createRedisKey(request);
  130.         String cacheData = this.redisTemplate.opsForValue().get(redisKey);
  131.         if(StringUtils.isEmpty(cacheData)){
  132.             //缓存未命中
  133.             return true;
  134.         }
  136.         // 将data数据进行响应
  137.         response.setCharacterEncoding("UTF-8");
  138.         response.setContentType("application/json; charset=utf-8");
  139.         response.getWriter().write(cacheData);
  141.         return false;
  142.     }
  144.     *//**
  145.      * 生成redis中的key，规则：SERVER_CACHE_DATA_MD5(url + param + token)
  146.      *
  147.      * @param request
  148.      * @return
  149.      *//*
  150.     public static String createRedisKey(HttpServletRequest request) throws Exception {
  151.         String url = request.getRequestURI();
  152.         String param = MAPPER.writeValueAsString(request.getParameterMap());
  153.         String token = request.getHeader("Authorization");
  155.         String data = url + "_" + param + "_" + token;
  156.         return "SERVER_CACHE_DATA_" + DigestUtils.md5Hex(data);
  157.     }*/
  158. }

application.properties：

  1. #是否开启数据缓存
  2. tanhua.cache.enable=false
  4. # Redis相关配置
  5. spring.redis.jedis.pool.max-wait = 5000ms
  6. spring.redis.jedis.pool.max-Idle = 100
  7. spring.redis.jedis.pool.min-Idle = 10
  8. spring.redis.timeout = 10s
  9. spring.redis.cluster.nodes = 192.168.31.81:6379,192.168.31.81:6380,192.168.31.81:6381
  10. spring.redis.cluster.max-redirects=5

注册拦截器到Spring容器：

  1. package com.tanhua.server.config;
  3. import com.tanhua.server.interceptor.RedisCacheInterceptor;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
  7. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  9. /**
  10.  * 该类为拦截器的配置类（将我们写的RedisCacheInterceptor注入到IoC容器中）
  11.  */
  13. @Configuration
  14. public class WebConfig implements WebMvcConfigurer {
  15.     //实现webMvcConfigurer接口
  17.     @Autowired
  18.     private RedisCacheInterceptor redisCacheInterceptor;
  20.     @Override
  21.     public void addInterceptors(InterceptorRegistry registry) {
  22.         //配置拦截的请求路径（拦截根路径下所有的请求）
  23.         registry.addInterceptor(this.redisCacheInterceptor).addPathPatterns("/*");
  24.     }
  25. }

4.3、响应结果写入到缓存

使用ResponseBodyAdvice进行对响应结果处理，将结果写入到Redis中：

具体实现：

  1. package com.tanhua.server.interceptor;
  3. import com.fasterxml.jackson.core.JsonProcessingException;
  4. import com.fasterxml.jackson.databind.ObjectMapper;
  5. import com.tanhua.server.utils.Cache;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.beans.factory.annotation.Value;
  8. import org.springframework.core.MethodParameter;
  9. import org.springframework.data.redis.core.RedisTemplate;
  10. import org.springframework.http.MediaType;
  11. import org.springframework.http.server.ServerHttpRequest;
  12. import org.springframework.http.server.ServerHttpResponse;
  13. import org.springframework.http.server.ServletServerHttpRequest;
  14. import org.springframework.stereotype.Component;
  15. import org.springframework.web.bind.annotation.ControllerAdvice;
  16. import org.springframework.web.bind.annotation.GetMapping;
  17. import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
  19. import javax.servlet.http.HttpServletRequest;
  20. import java.util.concurrent.TimeUnit;
  22. /**
  23.  * 该类为对响应结果进行写入redis的拦截器
  24.  */
  25. @ControllerAdvice
  26. public class MyResponseBodyAdvice implements ResponseBodyAdvice {
  27.     //开启redis缓存机制的配置
  28.     @Value("${tanhua.cache.enable}")
  29.     private Boolean enable;
  30.     //json转换类
  31.     private static final ObjectMapper MAPPER = new ObjectMapper();
  32.     //redis工具类
  33.     @Autowired
  34.     private RedisTemplate<String, String> redisTemplate;
  36.     @Override
  37.     public boolean supports(MethodParameter methodParameter, Class aClass) {
  38.         //只要满足redis换出开关为开启状态，是get请求，访问的controller是加有
  39.         //自定义注解Cache的，就把响应结果写入redis缓存中
  40.         return enable && methodParameter.hasMethodAnnotation(GetMapping.class)
  41.                 && methodParameter.hasMethodAnnotation(Cache.class);
  42.     }
  44.     @Override
  45.     public Object beforeBodyWrite(Object o,
  46.                                   MethodParameter methodParameter,
  47.                                   MediaType mediaType,
  48.                                   Class aClass,
  49.                                   ServerHttpRequest serverHttpRequest,
  50.                                   ServerHttpResponse serverHttpResponse) {
  51.         //如果满足上面的三个条件就进入到这个方法中来
  52.         //先判断参数一Object是否为空
  53.         if(o==null){
  54.             //如果为空就返回空
  55.             return null;
  56.         }
  57.         //如果不为空就将结果写入到redis中
  58.         //准备数据
  59.         //处理结果数据
  60.         try {
  61.             String redisValue= null;
  62.             if(o instanceof String){
  63.                 //如果o是String类型的则直接强转为String
  64.                 redisValue = (String)o;
  65.             }else{
  66.                 //如果不是则将对象转换成json格式的字符串
  68.                     redisValue = MAPPER.writeValueAsString(o);
  69.             }
  70.             //处理键
  71.             //将ServerHttpRequest强转为ServletServerHttpRequest
  72.             ServletServerHttpRequest servletServerHttpRequest = (ServletServerHttpRequest) serverHttpRequest;
  73.             HttpServletRequest request = servletServerHttpRequest.getServletRequest();
  74.             String redisKey = RedisCacheInterceptor.createRedisKey(request);
  75.             //获取Cache注解
  76.             Cache annotation = methodParameter.getMethodAnnotation(Cache.class);
  77.             String timeStr = annotation.time();
  78.             Long time = Long.valueOf(timeStr);
  79.             //参数一为redis的key，参数二为redis的值，参数三为有效的存储时间，参数四为时间单位秒
  80.             this.redisTemplate.opsForValue().set(redisKey,redisValue,time, TimeUnit.SECONDS);
  81.         } catch (Exception e) {
  82.             //如果出了异常就不写了
  83.             e.printStackTrace();
  84.         }
  85.         return o;
  86.     }
  87. }

4.4、测试

image-20201130202845964.png

可以看到数据已经缓存到Redis中，并且其缓存时间也是30秒，与预期一致。
image-20201130203238548.png

6、整合测试

测试时需要注意，由于用户数据较少，所以测试时需要把条件注释掉，否则查询不到数据：
image-20201130202631311.png

效果：
image-20201130200736231.png
image-20201130202349684.png