课程介绍 《探花交友》

  • 功能介绍
  • 项目介绍
  • 工程搭建
  • 短信验证码
  • 实现用户登录功能

1、功能介绍

探花交友是一个陌生人的在线交友平台，在该平台中可以搜索附近的人，查看好友动态，平台还会通过大数据计算进行智能推荐，通过智能推荐可以找到更加匹配的好友，这样才能增进用户对产品的喜爱度。探花平台还提供了在线即时通讯功能，可以实时的与好友进行沟通，让沟通随时随地的进行。

1.1、功能列表

功能 说明 备注
注册、登录 用户无需单独注册，直接通过手机号登录即可 首次登录成功后需要完善个人信息
交友 主要功能有：测灵魂、桃花传音、搜附近、探花等
圈子 类似微信朋友圈，用户可以发动态、查看好友动态等
消息 通知类消息 + 即时通讯消息
小视频 类似抖音，用户可以发小视频，评论等 显示小视频列表需要进行推荐算法计算后进行展现。
我的 我的动态、关注数、粉丝数、通用设置等

1.2、注册登录

业务说明：

用户通过手机验证码进行登录，如果是第一次登录则需要完善个人信息，在上传图片时，需要对上传的图片做人像的校验，防止用户上传非人像的图片作为头像。流程完成后，则登录成功。
1563681330146.png
1563681348382.png1563681365123.png
1563681382592.png
1563681397466.png
1563681412881.png

1.3、交友

交友是探花项目的核心功能之一，用户可以查看好友，添加好友，搜索好友等操作。
1563698504256.png

1.3.1、首页

在首页中，主要功能有“今日佳人”、“推荐”、“最近访客”等

  • 今日佳人
    • 按照“缘分值”进行匹配，将“缘分值”最高的用户展现出来
  • 推荐
    • 按照“缘分值”进行推荐，由后台的推荐系统计算得出，展现出来
  • 最近访客
    • 显示最近来看“我”的用户

1.3.2、探花

1563714212568.png

说明：左划喜欢，右划不喜欢，每天限量不超过100个，开通会员可增加限额。双方互相喜欢则配对成功。 实现：数据来源推荐系统计算后的结果。

1.3.3、搜附近

1563714826374.png

根据用户当前所在的位置进行查询，并且在10km的范围内进行查询，可以通过筛选按钮进行条件筛选。

1.3.4、桃花传音

功能类似QQ中的漂流瓶，用户可以发送和接收语音消息，陌生人就会接收到消息。
1563718868686.png

1.3.5、测灵魂

  1. 测试题用于对用户进行分类，每次提交答案后更新用户属性
  2. 测试题在后台进行维护
  3. 测试题测试完后产生结果页可以进行分享
  4. 测试题为顺序回答，回答完初级题解锁下一级问题
  5. 点击锁定问题 显示提示 请先回答上一级问题

1563719052277.png
1563719092059.png
1563719100855.png

1.4、圈子

1、推荐频道为根据问卷及喜好推荐相似用户动态

2、显示内容为用户头像、用户昵称、用户性别、用户年龄、用户标签和用户发布动态

3、图片最多不超过6张或发布一个小视频

4、动态下方显示发布时间距离当时时间，例如10分钟前、3小时前、2天前，显示时间进行取整

5、动态下方显示距离为发布动态地与本地距离

6、显示用户浏览量

7、显示点赞数、评论数 转发数
1563719380223.png
1563719403171.png

1.5、消息

消息包含通知类的消息和好友消息。
1563719621939.png

1.6、小视频

用户可以上传小视频，也可以查看小视频列表，并且可以进行点赞操作。
1563719761162.png

1.7、我的

显示关注数、喜欢数、粉丝数、我的动态等信息。
1563719894481.png
1563719949700.png

2、项目介绍

2.1、项目背景

在线社交是互联网时代的产物，已成为互联网用户的基础需求之一。移动互联网自2003年起快速发展，促使在线社交逐渐从PC端转移至移动端。移动社交最初以熟人社交为主，以维系熟人关系、共享资源信息的形式存在。随着人们交友需求的延伸，移动社交开始向陌生人社交、兴趣社交等垂直方向发展，形式丰富多样。

2.2、市场分析

探花交友项目定位于 陌生人交友市场。

  • 根据《2018社交领域投融资报告》中指出：虽然相比2017年，投融资事件减少29.5%，但是融资的总额却大幅增长，达到68%。
  • 这些迹象说明：社交领域的发展规模正在扩大，而很多没有特色的产品也会被淘汰。而随着那些尾部产品的倒下，对我们来说就是机会，及时抓住不同社交需求的机会。以社交为核心向不同的细分领域衍生正在逐渐走向成熟化。
  • 而我们按照娱乐形式和内容为主两个维度，将社交行业公司分类为：即时通信、内容社群、陌生人社交、泛娱乐社交以及兴趣社交几个领域。
  • 而在2018年社交的各个细分领域下，均有备受资本所关注的项目，根据烯牛数据2018年的报告中，也同样指出：内容社交及陌生人社交为资本重要关注领域，合计融资占比达73%。

clip_image002.jpeg

根据市场现状以及融资事件来看：陌生人社交、内容社群、兴趣社交在2019年仍然保持强劲的动力，占到近70%的比例，它们仍然是资本市场主要关注领域。从增长率来看陌生人社交的增长速度远远大于其他几类，因此我们要从这个方向入手。

2.3、目标用户群体

从整体年龄段来看：目前目标用户群体主要以30岁以下为主，其中以18-25岁年龄群体为主要受众人群。

  • 上班群体：热衷于通过分享内容或表达“个人情绪”在陌生人面前建立特殊的人设，并借此提升自我价值扩大自己的交际圈；
  • 学生群体：追求个性选择，更倾向找到有共同话题的陌生人对象并建立长期的关系，乐于展现自我；
  • 文艺群体：拥有自己独特的爱好且拥有特别的个人追求，追求文艺圈子内的交流，希望通过分享结交更多好友；
  • 沟通弱势群体：对现有长期保持线上对社交模式表现无力且无效，渴望有更加有效且安全的社交方式出现，解决目前单调乏味的沟通方式；

2.4、技术方案

前端：

  • flutter + android + 环信SDK + redux + shared_preferences + connectivity + iconfont + webview + sqflite

后端：

  • Spring Boot + SpringMVC + Mybatis + MybatisPlus + Dubbo
  • Elasticsearch geo 实现地理位置查询
  • MongoDB 实现海量数据的存储
  • Redis 数据的缓存
  • Spark + MLlib 实现智能推荐
  • 第三方服务 环信即时通讯
  • 第三方服务 阿里云 OSS 、 短信服务
  • 第三方服务 虹软开放平台

2.5、技术架构

1563457093887.png

2.6、技术解决方案

  • 使用Elasticsearch geo实现附近的人的解决方案
  • 使用Spark + Mllib实现智能推荐的解决方案
  • 使用MongoDB进行海量数据的存储的解决方案
  • 使用采用分布式文件系统存储小视频数据的解决方案
  • 使用虹软开放平台进行人脸识别的解决方案

2.7、技术亮点

  • 采用Elasticsearch geo实现地理位置查询
  • 采用RocketMQ作为消息服务中间件
  • 采用MongoDB进行海量数据的存储
  • 采用Spark + Mllib实现智能推荐
  • 采用环信服务实现即时通讯
  • 采用分布式文件系统存储小视频数据
  • 采用Apache Dobbo作为微服务架构技术
  • 采用SpringBoot + Mybatis实现系统主架构
  • 采用Redis集群实现缓存的高可用

2.8、开发方式

探花交友项目采用前后端分离的方式开发，就是前端由前端团队负责开发，后端负责接口的开发，这种开发方式有2点好处：

  • 扬长避短，每个团队做自己擅长的事情
  • 前后端并行开发，需要事先约定好接口地址以及各种参数、响应数据结构等

对于接口的定义我们采用YApi进行管理，YApi是一个开源的接口定义、管理、提供mock数据的管理平台。

地址：https://mock-java.itheima.net/ 用户名：tanhua@itcast.cn 密码：123456

image-20201017100705286.png

接口定义：
image-20201017100848313.png
mock数据，YApi提供了mock功能，就是模拟服务端返回测试数据：
image-20201017101228582.png
image-20201017101252482.png

还可以运行http请求（需要在Chrome中安装支持跨域扩展 https://juejin.im/post/6844904057707085832）：
image-20201017103028622.png
image-20201017103045864.png

2.9、基础环境

探花交友项目的开发统一使用提供的Centos7环境，该环境中部署安装了项目所需要的各种服务，如：MySQL、MongoDB、Redis、RocketMQ等。

  • 虚拟机的root用户密码为：root123
  • 默认参数：CPU：2核，内存：4G，硬盘：60G
  • IP地址建议设置为192.168.31.81，否则有些服务将不可用，比如：Redis、RocketMQ等。

3、注册登录

业务说明：

用户通过手机验证码进行登录，如果是第一次登录则需要完善个人信息，在上传图片时，需要对上传的图片做人像的校验，防止用户上传非人像的图片作为头像。流程完成后，则登录成功。

流程：
image-20201116105353320.png

3.1、单点登录系统

为什么要使用单点登录系统？

以前实现的登录和注册是在同一个tomcat内部完成，我们现在的系统架构是每一个系统都是由一个团队进行维护，每个系统都是单独部署运行一个单独的tomcat，所以，不能将用户的登录信息保存到session中（多个tomcat的session是不能共享的），所以我们需要一个单独的系统来维护用户的登录信息。
image-20201016221250343.png
image-20201117235203408.png

由上图可以看出：

  • 客户端需要通过SSO系统才能获取到token；
  • 客户端在请求服务系统时，服务系统需要通过SSO系统进行对token进行校验；
  • SSO系统在整个系统架构中处于核心位置；

3.2、搭建工程

3.2.1、my-tanhua

itcast-tanhua是父工程，集中定义了依赖的版本以及所需要的依赖信息。

  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.     <modelVersion>4.0.0</modelVersion>
  7.     <parent>
  8.         <groupId>org.springframework.boot</groupId>
  9.         <artifactId>spring-boot-starter-parent</artifactId>
  10.         <version>2.1.0.RELEASE</version>
  11.     </parent>
  13.     <groupId>cn.itcast.tanhua</groupId>
  14.     <artifactId>my-tanhua</artifactId>
  15.     <version>1.0-SNAPSHOT</version>
  17.     <!-- 集中定义依赖版本号 -->
  18.     <properties>
  19.         <mysql.version>5.1.47</mysql.version>
  20.         <jackson.version>2.9.9</jackson.version>
  21.         <druid.version>1.0.9</druid.version>
  22.         <servlet-api.version>2.5</servlet-api.version>
  23.         <jsp-api.version>2.0</jsp-api.version>
  24.         <joda-time.version>2.9.9</joda-time.version>
  25.         <commons-lang3.version>3.7</commons-lang3.version>
  26.         <commons-io.version>1.3.2</commons-io.version>
  27.         <mybatis.version>3.2.8</mybatis.version>
  28.         <mybatis.mybatis-plus>3.1.1</mybatis.mybatis-plus>
  29.         <lombok.version>1.18.4</lombok.version>
  30.     </properties>
  32.     <!--通用依赖-->
  33.     <dependencies>
  34.         <dependency>
  35.             <groupId>org.springframework.boot</groupId>
  36.             <artifactId>spring-boot-starter-test</artifactId>
  37.             <scope>test</scope>
  38.         </dependency>
  39.         <dependency>
  40.             <groupId>junit</groupId>
  41.             <artifactId>junit</artifactId>
  42.             <version>4.12</version>
  43.             <scope>test</scope>
  44.         </dependency>
  45.     </dependencies>
  47.     <dependencyManagement>
  48.         <dependencies>
  49.             <!-- mybatis-plus插件依赖 -->
  50.             <dependency>
  51.                 <groupId>com.baomidou</groupId>
  52.                 <artifactId>mybatis-plus</artifactId>
  53.                 <version>${mybatis.mybatis-plus}</version>
  54.             </dependency>
  55.             <dependency>
  56.                 <groupId>com.baomidou</groupId>
  57.                 <artifactId>mybatis-plus-boot-starter</artifactId>
  58.                 <version>${mybatis.mybatis-plus}</version>
  59.             </dependency>
  60.             <!-- MySql -->
  61.             <dependency>
  62.                 <groupId>mysql</groupId>
  63.                 <artifactId>mysql-connector-java</artifactId>
  64.                 <version>${mysql.version}</version>
  65.             </dependency>
  67.             <dependency>
  68.                 <groupId>org.mongodb</groupId>
  69.                 <artifactId>mongodb-driver-sync</artifactId>
  70.                 <version>3.9.1</version>
  71.             </dependency>
  72.             <dependency>
  73.                 <groupId>org.projectlombok</groupId>
  74.                 <artifactId>lombok</artifactId>
  75.                 <optional>true</optional>
  76.                 <version>${lombok.version}</version>
  77.             </dependency>
  78.             <dependency>
  79.                 <groupId>org.apache.commons</groupId>
  80.                 <artifactId>commons-lang3</artifactId>
  81.                 <version>${commons-lang3.version}</version>
  82.             </dependency>
  83.             <!--RocketMQ相关-->
  84.             <dependency>
  85.                 <groupId>org.apache.rocketmq</groupId>
  86.                 <artifactId>rocketmq-spring-boot-starter</artifactId>
  87.                 <version>2.0.3</version>
  88.             </dependency>
  89.             <dependency>
  90.                 <groupId>org.apache.rocketmq</groupId>
  91.                 <artifactId>rocketmq-client</artifactId>
  92.                 <version>4.6.0</version>
  93.             </dependency>
  94.             <!-- Jackson Json处理工具包 -->
  95.             <dependency>
  96.                 <groupId>com.fasterxml.jackson.core</groupId>
  97.                 <artifactId>jackson-databind</artifactId>
  98.                 <version>${jackson.version}</version>
  99.             </dependency>
  100.             <dependency>
  101.                 <groupId>com.alibaba</groupId>
  102.                 <artifactId>druid</artifactId>
  103.                 <version>${druid.version}</version>
  104.             </dependency>
  105.             <dependency>
  106.                 <groupId>commons-codec</groupId>
  107.                 <artifactId>commons-codec</artifactId>
  108.                 <version>1.11</version>
  109.             </dependency>
  110.             <dependency>
  111.                 <groupId>joda-time</groupId>
  112.                 <artifactId>joda-time</artifactId>
  113.                 <version>${joda-time.version}</version>
  114.             </dependency>
  115.             <dependency>
  116.                 <groupId>io.netty</groupId>
  117.                 <artifactId>netty-all</artifactId>
  118.                 <version>4.1.32.Final</version>
  119.             </dependency>
  120.             <!--zk依赖-->
  121.             <dependency>
  122.                 <groupId>org.apache.zookeeper</groupId>
  123.                 <artifactId>zookeeper</artifactId>
  124.                 <version>3.4.13</version>
  125.             </dependency>
  126.             <dependency>
  127.                 <groupId>com.github.sgroschupf</groupId>
  128.                 <artifactId>zkclient</artifactId>
  129.                 <version>0.1</version>
  130.             </dependency>
  131.             <!--dubbo的springboot支持-->
  132.             <dependency>
  133.                 <groupId>com.alibaba.boot</groupId>
  134.                 <artifactId>dubbo-spring-boot-starter</artifactId>
  135.                 <version>0.2.0</version>
  136.             </dependency>
  137.             <!--dubbo框架-->
  138.             <dependency>
  139.                 <groupId>com.alibaba</groupId>
  140.                 <artifactId>dubbo</artifactId>
  141.                 <version>2.6.4</version>
  142.             </dependency>
  143.             <dependency>
  144.                 <groupId>com.aliyun.oss</groupId>
  145.                 <artifactId>aliyun-sdk-oss</artifactId>
  146.                 <version>2.8.3</version>
  147.             </dependency>
  148.             <dependency>
  149.                 <groupId>com.aliyun</groupId>
  150.                 <artifactId>aliyun-java-sdk-core</artifactId>
  151.                 <version>4.5.3</version>
  152.             </dependency>
  153.             <dependency>
  154.                 <groupId>com.github.tobato</groupId>
  155.                 <artifactId>fastdfs-client</artifactId>
  156.                 <version>1.26.7</version>
  157.                 <exclusions>
  158.                     <exclusion>
  159.                         <groupId>ch.qos.logback</groupId>
  160.                         <artifactId>logback-classic</artifactId>
  161.                     </exclusion>
  162.                 </exclusions>
  163.             </dependency>
  164.             <dependency>
  165.                 <groupId>io.jsonwebtoken</groupId>
  166.                 <artifactId>jjwt</artifactId>
  167.                 <version>0.9.1</version>
  168.             </dependency>
  169.         </dependencies>
  170.     </dependencyManagement>
  172.     <build>
  173.         <plugins>
  174.             <!-- java编译插件 -->
  175.             <plugin>
  176.                 <groupId>org.apache.maven.plugins</groupId>
  177.                 <artifactId>maven-compiler-plugin</artifactId>
  178.                 <version>3.2</version>
  179.                 <configuration>
  180.                     <source>1.8</source>
  181.                     <target>1.8</target>
  182.                     <encoding>UTF-8</encoding>
  183.                 </configuration>
  184.             </plugin>
  185.         </plugins>
  186.     </build>
  188. </project>

3.2.2、my-tanhua-sso

  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.itcast.tanhua</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>my-tanhua-sso</artifactId>
  14.     <dependencies>
  15.         <dependency>
  16.             <groupId>org.springframework.boot</groupId>
  17.             <artifactId>spring-boot-starter-web</artifactId>
  18.         </dependency>
  19.         <dependency>
  20.             <groupId>com.baomidou</groupId>
  21.             <artifactId>mybatis-plus</artifactId>
  22.         </dependency>
  23.         <dependency>
  24.             <groupId>com.baomidou</groupId>
  25.             <artifactId>mybatis-plus-boot-starter</artifactId>
  26.         </dependency>
  27.         <dependency>
  28.             <groupId>mysql</groupId>
  29.             <artifactId>mysql-connector-java</artifactId>
  30.         </dependency>
  31.         <dependency>
  32.             <groupId>com.alibaba</groupId>
  33.             <artifactId>druid</artifactId>
  34.         </dependency>
  35.         <dependency>
  36.             <groupId>org.projectlombok</groupId>
  37.             <artifactId>lombok</artifactId>
  38.         </dependency>
  39.         <dependency>
  40.             <groupId>org.apache.commons</groupId>
  41.             <artifactId>commons-lang3</artifactId>
  42.         </dependency>
  43.         <dependency>
  44.             <groupId>com.fasterxml.jackson.core</groupId>
  45.             <artifactId>jackson-databind</artifactId>
  46.         </dependency>
  47.         <dependency>
  48.             <groupId>org.springframework.boot</groupId>
  49.             <artifactId>spring-boot-starter-data-redis</artifactId>
  50.         </dependency>
  51.         <dependency>
  52.             <groupId>commons-codec</groupId>
  53.             <artifactId>commons-codec</artifactId>
  54.         </dependency>
  56.         <!--RocketMQ相关-->
  57.         <dependency>
  58.             <groupId>org.apache.rocketmq</groupId>
  59.             <artifactId>rocketmq-spring-boot-starter</artifactId>
  60.         </dependency>
  61.         <dependency>
  62.             <groupId>org.apache.rocketmq</groupId>
  63.             <artifactId>rocketmq-client</artifactId>
  64.         </dependency>
  65.         <!--简化代码的工具包-->
  66.         <dependency>
  67.             <groupId>org.projectlombok</groupId>
  68.             <artifactId>lombok</artifactId>
  69.             <optional>true</optional>
  70.         </dependency>
  71.         <dependency>
  72.             <groupId>com.aliyun</groupId>
  73.             <artifactId>aliyun-java-sdk-core</artifactId>
  74.         </dependency>
  75.         <dependency>
  76.             <groupId>io.jsonwebtoken</groupId>
  77.             <artifactId>jjwt</artifactId>
  78.         </dependency>
  79.         <dependency>
  80.             <groupId>joda-time</groupId>
  81.             <artifactId>joda-time</artifactId>
  82.         </dependency>
  83.     </dependencies>
  86. </project>

3.2.3、网易模拟器

探花交友项目的前端采用Android APP的形式，所以我们需要使用模拟器或真机进行测试。

对于模拟器这里推荐使用网易模拟器，其兼容性好、功能完善而且还简洁，缺点是它不支持虚拟机中安装。

下载：https://mumu.163.com/
image-20201016214917500.png

3.3、数据库表

数据库使用的mysql：

  1. #user表
  2. CREATE TABLE `tb_user` (
  3.   `id` bigint(20) NOT NULL AUTO_INCREMENT,
  4.   `mobile` varchar(11) DEFAULT NULL COMMENT '手机号',
  5.   `password` varchar(32) DEFAULT NULL COMMENT '密码，需要加密',
  6.   `created` datetime DEFAULT NULL,
  7.   `updated` datetime DEFAULT NULL,
  8.   PRIMARY KEY (`id`),
  9.   KEY `mobile` (`mobile`) USING BTREE
  10. ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='用户表';
  12. #user_info表
  13. CREATE TABLE `tb_user_info` (
  14.   `id` bigint(20) NOT NULL AUTO_INCREMENT,
  15.   `user_id` bigint(20) NOT NULL COMMENT '用户id',
  16.   `nick_name` varchar(50) DEFAULT NULL COMMENT '昵称',
  17.   `logo` varchar(100) DEFAULT NULL COMMENT '用户头像',
  18.   `tags` varchar(50) DEFAULT NULL COMMENT '用户标签：多个用逗号分隔',
  19.   `sex` int(1) DEFAULT '3' COMMENT '性别，1-男，2-女，3-未知',
  20.   `age` int(11) DEFAULT NULL COMMENT '用户年龄',
  21.   `edu` varchar(20) DEFAULT NULL COMMENT '学历',
  22.   `city` varchar(20) DEFAULT NULL COMMENT '居住城市',
  23.   `birthday` varchar(20) DEFAULT NULL COMMENT '生日',
  24.   `cover_pic` varchar(50) DEFAULT NULL COMMENT '封面图片',
  25.   `industry` varchar(20) DEFAULT NULL COMMENT '行业',
  26.   `income` varchar(20) DEFAULT NULL COMMENT '收入',
  27.   `marriage` varchar(20) DEFAULT NULL COMMENT '婚姻状态',
  28.   `created` datetime DEFAULT NULL,
  29.   `updated` datetime DEFAULT NULL,
  30.   PRIMARY KEY (`id`),
  31.   KEY `user_id` (`user_id`)
  32. ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户信息表';

3.4、编写配置

application.properties 文件：

  1. #相关spring核心配置文件的命名
  2. spring.application.name=xiaoha-tanhua-sso
  3. #服务端口
  4. server.port=18080
  6. #数据源及数据库的连接配置
  7. spring.datasource.driver-class-name=com.mysql.jdbc.Driver
  8. spring.datasource.url=jdbc:mysql://192.168.31.81:3306/mytanhua?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&useSSL=false
  9. spring.datasource.username=root
  10. spring.datasource.password=root
  13. #枚举的包扫描（封装性别字段的枚举类）应用到的技术为mybatis-plus
  14. mybatis-plus.type-enums-package=cn.xiaoha.sso.enums
  15. #设定(通配)表名的前缀（应用到的技术为mybatis-plus）
  16. mybatis-plus.global-config.db-config.table-prefix=tb_
  17. #设置id策略为自增长（应用到的技术为mybatis-plus）
  18. mybatis-plus.global-config.db-config.id-type=auto
  20. #redis相关的配置
  21. #设置最长等待时间
  22. spring.redis.jedis.pool.max-wait=5000ms
  23. #设置最大活动连接数
  24. spring.redis.jedis.pool.max-idle=100
  25. #设置最小活动连接数
  26. spring.redis.jedis.pool.min-idle=10
  27. #设置连接超时时间
  28. spring.redis.timeout=10s
  29. #设置redis集群节点的ip地址和端口号
  30. spring.redis.cluster.nodes=192.168.31.81:6379,192.168.31.81:6380,192.168.31.81:6381
  31. spring.redis.cluster.max-redirects=5
  33. #设置rocketMQ相关的配置
  34. #配置rocketmq服务器的地址端口号
  35. rocketmq.name-server=192.168.31.81:9876
  36. #配置rocketmq的分组名
  37. rocketmq.producer.group=tanhua
  39. #xiaoha_tanhua
  40. #盐 值
  41. jwt.secret=76bd425b6f29f7fcc2e0bfc286043df1
  43. #虹软相关配置
  44. arcsoft.appid=*****
  45. arcsoft.sdkKey=****
  46. arcsoft.libPath=F:\\code\\WIN64

3.5、编写基础代码

3.5.1、Lombok

lombok 提供了简单的注解的形式来帮助我们简化消除一些必须有但显得很臃肿的 java 代码，尤其是针对pojo。

官网：https://projectlombok.org/

3.5.1.1、配置安装

导入依赖：

  1. <!--简化代码的工具包-->
  2. <dependency>
  3.     <groupId>org.projectlombok</groupId>
  4.     <artifactId>lombok</artifactId>
  5.     <optional>true</optional>
  6. </dependency>

安装IDEA插件：

如果不安装插件，程序可以正常执行，但是看不到生成的一些代码，如：get、set方法。1542036205393.png

3.5.1.2、常用注解
  • @Data：注解在类上；提供类所有属性的 getting 和 setting 方法，此外还提供了equals、canEqual、hashCode、toString 方法
  • @Setter：注解在属性上；为属性提供 setting 方法
  • @Getter：注解在属性上；为属性提供 getting 方法
  • @Slf4j：注解在类上；为类提供一个 属性名为log 的 slf4j日志对象
  • @NoArgsConstructor：注解在类上；为类提供一个无参的构造方法
  • @AllArgsConstructor：注解在类上；为类提供一个全参的构造方法
  • @Builder：使用Builder模式构建对象

测试一：使用@Data注解image-20201116113610810.png

是不是很神奇？！

测试二：使用@Slf4j注解

image-20201116113645107.png

测试：
image-20201116113812602.png

测试三：@AllArgsConstructor、@NoArgsConstructor注解的使用

image-20201116114013519.png

测试四：@Builder

image-20201116114233416.png

测试结果：
image-20201116114254202.png

3.5.2、创建编写SexEnum类

用户的性别用枚举进行表示。

  1. package cn.xiaoha.sso.enums;
  3. import com.baomidou.mybatisplus.core.enums.IEnum;
  5. public enum SexEnum implements IEnum<Integer> {
  6.     /**
  7.      * 封装性别的枚举
  8.      */
  9.     MAN(1,"男"),
  10.     WOMAN(2,"女"),
  11.     UNKNOWN(3,"未知");
  13.     private int value;
  14.     private String desc;
  15.     SexEnum(int value,String desc){
  16.         this.value = value;
  17.         this.desc = desc;
  18.     }
  21.     @Override
  22.     public Integer getValue() {
  23.         return this.value;
  24.     }
  26.     @Override
  27.     public String toString(){
  28.         return this.desc;
  29.     }
  31. }

3.5.3、创建编写User、UserInfo、BasePOJO实体类

  1. package cn.xiaoha.sso.pojo;
  3. import com.baomidou.mybatisplus.annotation.FieldFill;
  4. import com.baomidou.mybatisplus.annotation.TableField;
  6. import java.util.Date;
  8. @Data
  9. public class BasePOJO {
  10.     /**
  11.      * 该类为封装user表和userInfo表共同的拥有的字段
  12.      * created和updated;
  13.      */
  16.     //添加数据时的日期
  17.     @TableField(fill = FieldFill.INSERT)   //配置数据自动填充
  18.     private Date created;
  19.     //修改数据时的日期
  20.     @TableField(fill = FieldFill.INSERT_UPDATE) //配置数据自动填充
  21.     private Date updated;
  22. }
  1. package cn.xiaoha.sso.pojo;
  3. import com.fasterxml.jackson.annotation.JsonIgnore;
  4. import lombok.Data;
  6. import java.util.Date;
  9. @Data
  10. public class User extends BasePOJO {
  11.     /**
  12.      * 该类为映射tb_user表的实体类（数据封装类）
  13.      */
  14.     private Long id;
  15.     private String mobile;  //手机号
  16.     @JsonIgnore
  17.     private String password; //密码  json序列化时（将对象转为json格式字符串时忽略）
  18.     //private Date created;
  19.     //private Date updated;
  20. }
  1. package cn.xiaoha.sso.pojo;
  3. import cn.xiaoha.sso.enums.SexEnum;
  4. import lombok.Data;
  6. @Data
  7. public class UserInfo extends BasePOJO{
  8.     /**
  9.      * 该类为映射tb_user_info表的数据封装类
  10.      */
  12.     private Long id;
  13.     private Long userId; //用户id
  14.     private String nickName; //昵称
  15.     private String logo; //用户头像
  16.     private String tags; //用户标签：多个用逗号分隔
  17.     private SexEnum sex; //性别
  18.     private Integer age; //年龄
  19.     private String edu; //学历
  20.     private String city; //城市
  21.     private String birthday; //生日
  22.     private String coverPic; // 封面图片
  23.     private String industry; //行业
  24.     private String income; //收入
  25.     private String marriage; //婚姻状态
  26. }

3.5.4、创建编写MyMetaObjectHandler

对自动填充字段的处理：

  1. package cn.xiaoha.sso.hanlder;
  3. import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
  4. import org.apache.ibatis.reflection.MetaObject;
  6. import java.util.Date;
  8. public class MyMetaObjectHandler implements MetaObjectHandler {
  9.     /*
  10.     *  该类是对自动填充的字段做进一步的手动处理
  11.     */
  13.     /**
  14.      * 此方法是对新添加数据的created和updated做一个非空的判断和设置
  15.      * @param metaObject
  16.      */
  17.     @Override
  18.     public void insertFill(MetaObject metaObject) {
  19.         //获取created对象
  20.         Object created = getFieldValByName("created", metaObject);
  21.         //做非空判断
  22.         if(created==null){
  23.             //为空，就添加  参数一为指定的字段名，
  24.             // 参数二为需要添加的新日期对象
  25.             setFieldValByName("created",new Date(),metaObject);
  26.         }
  27.         //获取updated对象
  28.         Object updated = getFieldValByName("updated", metaObject);
  29.         //做非空判断
  30.         if(updated==null){
  31.             setFieldValByName("updated",new Date(),metaObject);
  32.         }
  33.     }
  35.     /**
  36.      * 此方法是对修改数据时对updated的设置
  37.      * @param metaObject
  38.      */
  39.     @Override
  40.     public void updateFill(MetaObject metaObject) {
  41.         //修改时不需要做非空判断，因为修改的数据肯定是不为空的
  42.         //而且只要处理updated的字段
  43.         //Object updated = getFieldValByName("updated", metaObject);
  44.         setFieldValByName("updated",new Date(),metaObject);
  45.     }
  46. }

3.5.5、创建编写UserMapper（技术实现mybatis-plus）

  1. package cn.xiaoha.sso.mapper;
  3. import cn.xiaoha.sso.pojo.User;
  4. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  5. import org.apache.ibatis.annotations.Mapper;
  6. import org.springframework.stereotype.Repository;
  8. //@Mapper
  9. @Repository
  10. public interface UserMapper extends BaseMapper<User> {
  11. }
  1. package com.tanhua.sso.mapper;
  3. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  4. import com.tanhua.sso.pojo.UserInfo;
  6. public interface UserInfoMapper extends BaseMapper<UserInfo> {
  8. }

3.5.6、MyApplication

SpringBoot的启动类。

  1. package cn.xiaoha.sso;
  3. import org.mybatis.spring.annotation.MapperScan;
  4. import org.springframework.boot.SpringApplication;
  5. import org.springframework.boot.autoconfigure.SpringBootApplication;
  6. @MapperScan("cn.xiaoha.sso.mapper")
  7. @SpringBootApplication
  8. public class MySpringApplication {
  9.     public static void main(String[] args) {
  10.         SpringApplication.run(MySpringApplication.class,args);
  11.     }
  12. }

3.6、短信验证码

发送短信验证码的流程：
image-20201116090449776.png

流程说明：

  • 用户向SSO系统发送请求，在请求中传递手机号；
  • SSO系统接收到请求后，生成随机验证码以及短信内容，请求阿里云短信服务；
  • 阿里云短信服务接收到请求后，会进行一系列的验证，比如账号余额、短信模板是否正确等，最后向运营商发起请求；
  • 运营商接收到请求后，向该手机号下发短信，用户即可收到短信；

3.6.1、阿里云短信服务

3.6.1.1、申请签名与模板

https://dysms.console.aliyun.com/dysms.htm?spm=5176.12818093.0.ddysms.2a4316d0ql6PyD
image-20201016193819097.png

说明：申请签名时，个人用户只能申请一个并且签名的名称必须为“ABC商城”，否则审核不通过。

申请模板：
image-20201016193927924.png

审核时间需要1

3.6.1.2、设置用户权限

在阿里云中，需要在RAM服务中创建用户以及权限，才能通过api进行访问接口。
image-20201016194331790.png

创建用户：
image-20201016194409024.png
image-20201016195011698.pngimage-20201016194636739.png

创建完成后要保存AccessKey Secret和AccessKey ID，AccessKey Secret只显示这一次，后面将不再显示。

添加权限：

3.6.1.3、编写发送短信的测试类SendSms

文档：https://help.aliyun.com/document_detail/101414.html?spm=a2c4g.11186623.6.625.18705ffa8u4lwj：

  1. package com.xiaoha.sso.test;
  3. import com.aliyuncs.CommonRequest;
  4. import com.aliyuncs.CommonResponse;
  5. import com.aliyuncs.DefaultAcsClient;
  6. import com.aliyuncs.IAcsClient;
  7. import com.aliyuncs.exceptions.ClientException;
  8. import com.aliyuncs.exceptions.ServerException;
  9. import com.aliyuncs.http.MethodType;
  10. import com.aliyuncs.profile.DefaultProfile;
  12.     /*
  13.     pom.xml
  14.     <dependency>
  15.       <groupId>com.aliyun</groupId>
  16.       <artifactId>aliyun-java-sdk-core</artifactId>
  17.       <version>4.5.3</version>
  18.     </dependency>
  19.     */
  21. public class MageTest {
  23.         public static void main(String[] args) {
  24.             DefaultProfile profile = DefaultProfile.getProfile("cn-hangzhou",
  25.                     "LTAI4GAcwoRi7xR3GUUrayCL", "6hWIMDC7a8kLLRxXN9nzI0x3wQ2biS");
  26.             IAcsClient client = new DefaultAcsClient(profile);
  28.             CommonRequest request = new CommonRequest();
  29.             request.setSysMethod(MethodType.POST);
  30.             request.setSysDomain("dysmsapi.aliyuncs.com");
  31.             request.setSysVersion("2017-05-25");
  32.             request.setSysAction("SendSms");
  33.             request.putQueryParameter("RegionId", "cn-hangzhou");
  34.             //request.putQueryParameter("PhoneNumbers", "15874204087"); //目标手机号
  35.             request.putQueryParameter("SignName", "青橙"); //签名名称
  36.             request.putQueryParameter("TemplateCode", "SMS_205136201"); //短信模板code
  37.             request.putQueryParameter("TemplateParam", "{\"code\":\"123456\"}");//模板中变量替换
  38.             try {
  39.                 CommonResponse response = client.getCommonResponse(request);
  41.                 //{"Message":"OK","RequestId":"EC2D4C9A-0EAC-4213-BE45-CE6176E1DF23","BizId":"110903802851113360^0","Code":"OK"}
  42.                 System.out.println(response.getData());
  43.             } catch (ServerException e) {
  44.                 e.printStackTrace();
  45.             } catch (ClientException e) {
  46.                 e.printStackTrace();
  48.             }
  49.     }
  50. }

3.6.1.4、实现发送短信方法（功能）

配置文件：aliyun.properties 文件

  1. aliyun.sms.regionId = cn-hangzhou
  2. aliyun.sms.accessKeyId = LTAI4GAcwoRi7xR3GUUrayCL
  3. aliyun.sms.accessKeySecret = 6hWIMDC7a8kLLRxXN9nzI0x3wQ2biS
  4. aliyun.sms.domain= dysmsapi.aliyuncs.com
  5. aliyun.sms.signName=青橙
  6. aliyun.sms.templateCode= SMS_205136201

需要注意中文编码问题：
image-20201016203847636.png

创建读取配置的配置类：

  1. package cn.xiaoha.sso.config;
  4. import lombok.Data;
  5. import org.springframework.boot.context.properties.ConfigurationProperties;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.context.annotation.PropertySource;
  9. @Configuration
  10. @PropertySource("classpath:aliyun.properties") //指定配置文件的路径
  11. @ConfigurationProperties(prefix = "aliyun.sms")//设置前缀
  12. @Data
  13. public class AliyunSMSConfig {
  14.     private String regionId;
  15.     private String accessKeyId;
  16.     private String accessKeySecret;
  17.     private String domain;
  18.     private String signName;
  19.     private String templateCode;
  20. }

service层的代码实现：

  1. package cn.xiaoha.sso.service;
  3. import cn.xiaoha.sso.config.AliyunSMSConfig;
  4. import cn.xiaoha.sso.vo.ErrorResult;
  5. import com.aliyuncs.CommonRequest;
  6. import com.aliyuncs.CommonResponse;
  7. import com.aliyuncs.DefaultAcsClient;
  8. import com.aliyuncs.IAcsClient;
  9. import com.aliyuncs.exceptions.ClientException;
  10. import com.aliyuncs.exceptions.ServerException;
  11. import com.aliyuncs.http.MethodType;
  12. import com.aliyuncs.profile.DefaultProfile;
  13. import io.netty.util.internal.StringUtil;
  14. import lombok.extern.slf4j.Slf4j;
  15. import org.apache.commons.lang3.RandomUtils;
  16. import org.apache.commons.lang3.StringUtils;
  17. import org.springframework.beans.factory.annotation.Autowired;
  18. import org.springframework.data.redis.core.RedisTemplate;
  19. import org.springframework.stereotype.Service;
  21. import java.time.Duration;
  23. @Service
  24. @Slf4j
  25. public class SendSms {
  27.     //注入redisTemplate的工具类
  28.     //泛型一定要写
  29.     @Autowired
  30.     private RedisTemplate<String,String> redisTemplate;
  32.     //将封装有参数的配置配置类注入过来
  33.     @Autowired
  34.     private AliyunSMSConfig aliyunSMSConfig;
  36.     /**
  37.      * 发送验证码的方法
  38.      * @param mobile  方法参数为接收验证码的手机号
  39.      * @return  返回结果为验证码
  40.      */
  41.     public String getSendSMS(String mobile){
  42.         String code = "123456";
  44.         DefaultProfile profile = DefaultProfile.getProfile(this.aliyunSMSConfig.getRegionId(),
  45.                 this.aliyunSMSConfig.getAccessKeyId(), this.aliyunSMSConfig.getAccessKeySecret());
  46.         IAcsClient client = new DefaultAcsClient(profile);
  47.         //随机生成的六位数验证码
  48.         //String code = RandomUtils.nextInt(100000,999999)+"";
  49.         //向目标手机发送验证码
  50.         CommonRequest request = new CommonRequest();
  51.         request.setSysMethod(MethodType.POST);
  52.         request.setSysDomain(this.aliyunSMSConfig.getDomain());
  53.         request.setSysVersion("2017-05-25");
  54.         request.setSysAction("SendSms");
  55.         request.putQueryParameter("RegionId", this.aliyunSMSConfig.getRegionId());
  56.         request.putQueryParameter("PhoneNumbers", mobile); //目标手机号(接收验证码的手机号)
  57.         request.putQueryParameter("SignName", this.aliyunSMSConfig.getSignName()); //签名名称
  58.         request.putQueryParameter("TemplateCode", this.aliyunSMSConfig.getTemplateCode()); //短信模板code
  59.         request.putQueryParameter("TemplateParam", "{\"code\":"+code+"}");//模板中变量替换
  60.         try {
  61.             CommonResponse response = client.getCommonResponse(request);
  62.             String data = response.getData();
  63.             //String data = code;
  64.             //判断结果，一般结果为：{"Message":"OK","RequestId":"EC2D4C9A-0EAC-4213-BE45-CE6176E1DF23","BizId":"110903802851113360^0","Code":"OK"}
  65.             if (StringUtils.contains(data,"\"Message\":\"OK\"")){
  66.                 //如果数据中（结果）存在"Message":"OK"，说明成功的发送了验证码
  67.                 //返回验证码
  68.                 return code;
  69.             }
  72.             log.info("发送成功 ， data=",data);
  73.             //System.out.println(response.getData());
  75.         } catch (Exception e) {
  76.             //e.printStackTrace();
  77.             log.error("发送失败 ,mobile=",mobile,e);
  78.         }
  79.         //报错则没有成功的发送验证码，其实也不会走return null
  80.         //只是骗骗编译器
  81.         return null;
  82.     }
  85.     public ErrorResult sendCheckCode(String phone) {
  86.         //先判断redis中的验证码是否失效了
  87.         String redisKey = "CHECK_CODE_"+phone;
  88.         if (this.redisTemplate.hasKey(redisKey)) {
  89.             //如果redis中有该键则不用再次发
  90.             //返货发送失败
  91.             String mes = "验证码还没有失效";
  92.             ErrorResult errorResult = ErrorResult.builder().errCode("000000").errMessage(mes).build();
  93.             return errorResult;
  94.         }
  95.         //调用getSendSms方法发送验证码
  96.         String code = this.getSendSMS(phone);
  97.         //判断验证码是否为空
  98.         if(StringUtils.isEmpty(code)){
  99.             //为空则发送验证码失败
  100.             String mes = "发送验证码失败";
  101.             ErrorResult errorResult = ErrorResult.builder().errCode("000002").errMessage(mes).build();
  102.             return errorResult;
  103.         }
  105.         //如果成功的发送验证码，就把验证码存入到redis中
  106.         this.redisTemplate.opsForValue().set(redisKey,code, Duration.ofMinutes(10));
  108.         //没有错误就返回null
  109.         return null;
  110.     }
  111. }

3.6.2、SSO短信接口服务

3.6.2.1、mock接口

地址：https://mock-java.itheima.net/project/35/interface/api/581
1564535110994.png

3.6.2.2、编写接口服务

编写ErrorResult，ErrorResult对象是与前端约定好的结构，如果发生错误需要返回该对象，如果未发生错误响应200即可。

  1. package cn.xiaoha.sso.vo;
  3. import lombok.Builder;
  4. import lombok.Data;
  6. @Data
  7. @Builder
  8. public class ErrorResult {
  10.     /**
  11.      * 该类为封装结果的类
  12.      * 发生错误返回该类的对象
  13.      * 未发生错误直接返回200，
  14.      * 即可
  15.      */
  16.     //错误的代码
  17.     private String errCode;
  18.     //错误的提示信息
  19.     private String errMessage;
  20. }

SmsController：

  1. package cn.xiaoha.sso.controller;
  3. import cn.xiaoha.sso.service.SendSms;
  4. import cn.xiaoha.sso.vo.ErrorResult;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.apache.commons.lang3.StringUtils;
  7. import org.springframework.beans.factory.annotation.Autowired;
  8. import org.springframework.http.HttpStatus;
  9. import org.springframework.http.ResponseEntity;
  10. import org.springframework.web.bind.annotation.PostMapping;
  11. import org.springframework.web.bind.annotation.RequestBody;
  12. import org.springframework.web.bind.annotation.RequestMapping;
  13. import org.springframework.web.bind.annotation.RestController;
  15. import java.util.Map;
  18. @Slf4j
  19. @RestController
  20. @RequestMapping("user")
  21. public class SmsController {
  22.     //注入service层
  23.     @Autowired
  24.     private SendSms sendSms;
  26.     @PostMapping("login")
  27.     public ResponseEntity<ErrorResult> sendCheckCode(@RequestBody Map<String,String>param){
  28.         //获取请求参数的值
  29.         String phone = param.get("phone");
  30.         ErrorResult errorResult = null;
  31.         try {
  32.             //调用service层发送检测验证码的方法
  33.             //返回值为ErrorResult对象，参数为手机号
  34.             errorResult=this.sendSms.sendCheckCode(phone);
  35.             //判断errorResult结果,为空表示没有出错，则发送验证码正常
  36.             if(errorResult==null){
  37.                 //返回200状态码即可
  38.                 return ResponseEntity.ok(null);
  39.             }
  40.         } catch (Exception e) {
  41.             //e.printStackTrace();
  42.             log.info("发送短信失败，phone=",phone,e);
  44.             //出错了就新制造一个错
  45.             String mes = "验证码发送失败";
  46.             errorResult = ErrorResult.builder().errCode("000001").errMessage(mes).build();
  47.         }
  48.         return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResult);
  49.     }
  50. }

SmsService：

  1. package cn.xiaoha.sso.service;
  3. import cn.xiaoha.sso.config.AliyunSMSConfig;
  4. import cn.xiaoha.sso.vo.ErrorResult;
  5. import com.aliyuncs.CommonRequest;
  6. import com.aliyuncs.CommonResponse;
  7. import com.aliyuncs.DefaultAcsClient;
  8. import com.aliyuncs.IAcsClient;
  9. import com.aliyuncs.exceptions.ClientException;
  10. import com.aliyuncs.exceptions.ServerException;
  11. import com.aliyuncs.http.MethodType;
  12. import com.aliyuncs.profile.DefaultProfile;
  13. import io.netty.util.internal.StringUtil;
  14. import lombok.extern.slf4j.Slf4j;
  15. import org.apache.commons.lang3.RandomUtils;
  16. import org.apache.commons.lang3.StringUtils;
  17. import org.springframework.beans.factory.annotation.Autowired;
  18. import org.springframework.data.redis.core.RedisTemplate;
  19. import org.springframework.stereotype.Service;
  21. import java.time.Duration;
  23. @Service
  24. @Slf4j
  25. public class SendSms {
  27.     //注入redisTemplate的工具类
  28.     //泛型一定要写
  29.     @Autowired
  30.     private RedisTemplate<String,String> redisTemplate;
  32.     //将封装有参数的配置配置类注入过来
  33.     @Autowired
  34.     private AliyunSMSConfig aliyunSMSConfig;
  36.     /**
  37.      * 发送验证码的方法
  38.      * @param mobile  方法参数为接收验证码的手机号
  39.      * @return  返回结果为验证码
  40.      */
  41.     public String getSendSMS(String mobile){
  42.         String code = "123456";
  44.         DefaultProfile profile = DefaultProfile.getProfile(this.aliyunSMSConfig.getRegionId(),
  45.                 this.aliyunSMSConfig.getAccessKeyId(), this.aliyunSMSConfig.getAccessKeySecret());
  46.         IAcsClient client = new DefaultAcsClient(profile);
  47.         //随机生成的六位数验证码
  48.         //String code = RandomUtils.nextInt(100000,999999)+"";
  49.         //向目标手机发送验证码
  50.         CommonRequest request = new CommonRequest();
  51.         request.setSysMethod(MethodType.POST);
  52.         request.setSysDomain(this.aliyunSMSConfig.getDomain());
  53.         request.setSysVersion("2017-05-25");
  54.         request.setSysAction("SendSms");
  55.         request.putQueryParameter("RegionId", this.aliyunSMSConfig.getRegionId());
  56.         request.putQueryParameter("PhoneNumbers", mobile); //目标手机号(接收验证码的手机号)
  57.         request.putQueryParameter("SignName", this.aliyunSMSConfig.getSignName()); //签名名称
  58.         request.putQueryParameter("TemplateCode", this.aliyunSMSConfig.getTemplateCode()); //短信模板code
  59.         request.putQueryParameter("TemplateParam", "{\"code\":"+code+"}");//模板中变量替换
  60.         try {
  61.             CommonResponse response = client.getCommonResponse(request);
  62.             String data = response.getData();
  63.             //String data = code;
  64.             //判断结果，一般结果为：{"Message":"OK","RequestId":"EC2D4C9A-0EAC-4213-BE45-CE6176E1DF23","BizId":"110903802851113360^0","Code":"OK"}
  65.             if (StringUtils.contains(data,"\"Message\":\"OK\"")){
  66.                 //如果数据中（结果）存在"Message":"OK"，说明成功的发送了验证码
  67.                 //返回验证码
  68.                 return code;
  69.             }
  72.             log.info("发送成功 ， data=",data);
  73.             //System.out.println(response.getData());
  75.         } catch (Exception e) {
  76.             //e.printStackTrace();
  77.             log.error("发送失败 ,mobile=",mobile,e);
  78.         }
  79.         //报错则没有成功的发送验证码，其实也不会走return null
  80.         //只是骗骗编译器
  81.         return null;
  82.     }
  85.     public ErrorResult sendCheckCode(String phone) {
  86.         //先判断redis中的验证码是否失效了
  87.         String redisKey = "CHECK_CODE_"+phone;
  88.         if (this.redisTemplate.hasKey(redisKey)) {
  89.             //如果redis中有该键则不用再次发
  90.             //返货发送失败
  91.             String mes = "验证码还没有失效";
  92.             ErrorResult errorResult = ErrorResult.builder().errCode("000000").errMessage(mes).build();
  93.             return errorResult;
  94.         }
  95.         //调用getSendSms方法发送验证码
  96.         String code = this.getSendSMS(phone);
  97.         //判断验证码是否为空
  98.         if(StringUtils.isEmpty(code)){
  99.             //为空则发送验证码失败
  100.             String mes = "发送验证码失败";
  101.             ErrorResult errorResult = ErrorResult.builder().errCode("000002").errMessage(mes).build();
  102.             return errorResult;
  103.         }
  105.         //如果成功的发送验证码，就把验证码存入到redis中
  106.         this.redisTemplate.opsForValue().set(redisKey,code, Duration.ofMinutes(10));
  108.         //没有错误就返回null
  109.         return null;
  110.     }
  111. }

3.7、JWT

3.7.1、简介

JSON Web token简称JWT， 是用于对应用程序上的用户进行身份验证的标记。也就是说, 使用 JWTS 的应用程序不再需要保存有关其用户的 cookie 或其他session数据。此特性便于可伸缩性, 同时保证应用程序的安全。

在身份验证过程中, 当用户使用其凭据成功登录时, 将返回 JSON Web token, 并且必须在本地保存 (通常在本地存储中)。

每当用户要访问受保护的路由或资源 (端点) 时, 用户代理(user agent)必须连同请求一起发送 JWT, 通常在授权标头中使用Bearer schema。后端服务器接收到带有 JWT 的请求时, 首先要做的是验证token。

3.7.2、格式

  • JWT就是一个字符串，经过加密处理与校验处理的字符串，形式为：A.B.C
  • A由JWT头部信息header经过base64加密得到
    • ```json

      默认的头信息

      { “alg”: “HS256”, “typ”: “JWT” }

官网测试：https://jwt.io/

base64加密后的字符串为：eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9

  2. - B是payload，存放有效信息的地方，这些信息包含三个部分：
  3.    - 标准中注册的声明 (建议但不强制使用)
  4.       - iss: jwt签发者
  5.       - sub: jwt所面向的用户
  6.       - aud: 接收jwt的一方
  7.       - exp: jwt的过期时间，这个过期时间必须要大于签发时间
  8.       - nbf: 定义在什么时间之前，该jwt都是不可用的.
  9.       - iat: jwt的签发时间
  10.       - jti: jwt的唯一身份标识，主要用来作为一次性token,从而回避重放攻击。
  11.    - 公共的声明
  12.       - 公共的声明可以添加任何的信息，一般添加用户的相关信息或其他业务需要的必要信息.但不建议添加敏感信息，因为该部分在客户端可解密.
  13.    - 私有的声明
  14.       - 私有声明是提供者和消费者所共同定义的声明，一般不建议存放敏感信息，因为base64是对称解密的，意味着该部分信息可以归类为明文信息。
  15.    - ```json
  16. #存放的数据：
  17. {
  18.   "sub": "1234567890",
  19.   "name": "John Doe",
  20.   "iat": 1516239022
  21. }
  23. #base64后的字符串为：
  24. eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ
  • C由A和B通过加密算法得到，用作对token进行校验，看是否有效
    • 这个部分需要base64加密后的header和base64加密后的payload使用.连接组成的字符串，然后通过header中声明的加密方式进行加盐secret组合加密，然后就构成了jwt的第三部分。
    • ```json

      secret为：itcast

      得到的加密字符串为：DwMTjJktoFFdClHqjJMRgYzICo6FJOUc3Jmev9EScBc

整体的token为：eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.DwMTjJktoFFdClHqjJMRgYzICo6FJOUc3Jmev9EScBc

  3. <a name="f4440c9a"></a>
  4. #### 3.7.3、流程
  5. ![1563895628713.png](https://cdn.nlark.com/yuque/0/2021/png/12492094/1611898540266-73c4b97d-472a-4644-af9e-72110cb68c68.png#align=left&display=inline&height=535&margin=%5Bobject%20Object%5D&name=1563895628713.png&originHeight=535&originWidth=926&size=83513&status=done&style=none&width=926)
  7. <a name="aa0c0b0b"></a>
  8. #### 3.7.4、示例
  10. 导入依赖：
  12. ```xml
  13. <dependency>
  14.     <groupId>io.jsonwebtoken</groupId>
  15.     <artifactId>jjwt</artifactId>
  16.     <version>0.9.1</version>
  17. </dependency>

编写测试用例：

  1. package com.xiaoha.sso.test;
  3. import io.jsonwebtoken.*;
  4. import org.junit.Test;
  6. import java.util.Date;
  7. import java.util.HashMap;
  8. import java.util.Map;
  10. public class TestJWT {
  11.     //定义一个解密的秘钥
  12.     String secret  = "xiaoha";
  14.     @Test
  15.     public void createJIT(){
  16.         //数据的准备
  17.         //头信息
  18.         Map<String,Object> header = new HashMap<String,Object>();
  19.         header.put(JwsHeader.TYPE,JwsHeader.JWT_TYPE);
  20.         header.put(JwsHeader.ALGORITHM,"HS256");
  21.         //中间部分
  22.         Map<String,Object> claims = new HashMap<String,Object>();
  23.         claims.put("mobile","12345678910");
  24.         claims.put("id","2");
  26.         //生成token核心代码
  27.         String jwt = Jwts.builder()
  28.                 .setHeader(header)//header ,可以省略
  29.                 .setClaims(claims) //payload，存储数据的位置，不能放置敏感的数据，如：密码等
  30.                 .signWith(SignatureAlgorithm.HS256,secret)//设置加密的方法和加密盐
  31.                 .setExpiration(new Date(System.currentTimeMillis()+300000))//设置过期时间，当前时间加指定过期的时间
  32.                 .compact();
  33.         System.out.println(jwt);
  34.     }
  36.     //测试解析token、
  37. @Test
  38.     public void decodeToken(){
  39.         //准备要解析的token
  40.         String token = "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJtb2JpbGUiOiIxMjM0NTY3ODkxMCIsImlkIjoiMiIsImV4cCI6MTYxMTgzMzAzMn0.5qvBoxzfNYlTOmPlV93zJ-k-DMtClZSZbJAJv5nya9s";
  42.         try{
  43.             Map<String,Object> body = Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
  44.             System.out.println(body);
  45.         }catch(ExpiredJwtException e){
  46.             System.out.println("token已经过期了");
  47.         }catch(Exception e){
  48.             System.out.println("无效的token");
  49.         }
  51.     }
  52. }

3.8、用户登录

用户接收到验证码后，进行输入验证码，点击登录，前端系统将手机号以及验证码提交到SSO进行校验。
image-20201118231431191.png

3.7.1、mock接口

接口地址：https://mock-java.itheima.net/project/164/interface/api/12593
1564300265546.png

3.7.2、创建编写UserController类

  1. package cn.xiaoha.sso.controller;
  3. import cn.xiaoha.sso.service.UserService;
  4. import cn.xiaoha.sso.vo.ErrorResult;
  5. import org.apache.commons.lang3.StringUtils;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.http.HttpStatus;
  8. import org.springframework.http.ResponseEntity;
  9. import org.springframework.web.bind.annotation.PostMapping;
  10. import org.springframework.web.bind.annotation.RequestBody;
  11. import org.springframework.web.bind.annotation.RequestMapping;
  12. import org.springframework.web.bind.annotation.RestController;
  14. import java.util.HashMap;
  15. import java.util.Map;
  17. @RestController
  18. @RequestMapping("user")
  19. public class UserController {
  21.     //注入UserService层
  22.     @Autowired
  23.     private UserService userService;
  25.     /**
  26.      * 用户登录验证方法
  27.      * @param param 封装了请求参数：手机号和验证码
  28.      * @return 返回值包括isNew和token
  29.      */
  30.     @PostMapping("loginVerification")
  31.     public ResponseEntity<Object> loginVerification(@RequestBody Map<String,String> param){
  32.         ErrorResult error = null;
  33.         try {
  34.             //获取请求参数
  35.             String phone = param.get("phone");
  36.             String code = param.get("verificationCode");
  37.             //调用service层
  38.             String data = this.userService.login(phone,code);
  39.             //判断data是否不为空
  40.             if(StringUtils.isNotEmpty(data)){
  41.                 //不为空则表示登录成功
  42.                 String[] split = StringUtils.split(data,"|");
  43.                 Map<String,String> result = new HashMap<String,String>();
  44.                 result.put("token",split[0]);
  45.                 result.put("isNew",split[1]);
  46.                 return ResponseEntity.ok(result);
  47.             }
  48.         } catch (Exception e) {
  49.             e.printStackTrace();
  50.             //如果出错了
  51.             //就抛出一个异常
  52.             error = ErrorResult.builder().errCode("000003").errMessage("登录失败，请重试").build();
  53.         }
  54.         return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(error);
  55.     }
  56. }

3.7.3、UserService

  1. package cn.xiaoha.sso.service;
  3. import cn.xiaoha.sso.mapper.UserMapper;
  4. import cn.xiaoha.sso.pojo.User;
  5. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  6. import io.jsonwebtoken.Jwts;
  7. import io.jsonwebtoken.SignatureAlgorithm;
  8. import lombok.extern.slf4j.Slf4j;
  9. import org.apache.commons.codec.digest.DigestUtils;
  10. import org.apache.commons.lang3.StringUtils;
  11. import org.apache.rocketmq.spring.core.RocketMQTemplate;
  12. import org.joda.time.DateTime;
  13. import org.springframework.beans.factory.annotation.Autowired;
  14. import org.springframework.beans.factory.annotation.Value;
  15. import org.springframework.data.redis.core.RedisTemplate;
  16. import org.springframework.messaging.MessagingException;
  17. import org.springframework.stereotype.Service;
  19. import java.util.HashMap;
  20. import java.util.Map;
  22. @Slf4j
  23. @Service
  24. public class UserService {
  25.     //从配置文件中获取secret
  26.     @Value("${jwt.secret}")
  27.     private String secret;
  28.     //注入redis
  29.     @Autowired
  30.     private RedisTemplate<String,String> redisTemplate;
  31.     //注入userMapper
  32.     @Autowired
  33.     private UserMapper userMapper;
  34.     //注入rocketMQTemplate
  35.     @Autowired
  36.     private RocketMQTemplate rocketMQTemplate;
  38.     /**
  39.      *  登录验证
  40.      * @param phone 手机号
  41.      * @param code  验证码
  42.      * @return
  43.      */
  44.     public String login(String phone, String code) {
  45.         //先去redis中核对验证码
  46.         String redisKey  = "CHECK_CODE_"+phone;
  47.         //定义一个标记isNew，该标记为是否为新用户
  48.         boolean isNew = false ;
  50.         //获取redis中的验证码
  51.         String redisValue = this.redisTemplate.opsForValue().get(redisKey);
  53.         //核对验证码
  54.         if(!StringUtils.equals(code,redisValue)){
  55.             //验证码和redis中的不相同则登录失败
  56.             return null;
  57.         }
  58.         //如果验证码通过则把redis中的数据删除
  59.         //redisTemplate.delete(redisKey);
  61.         //之后调用mapper查询数据库，看是不是新用户
  62.         QueryWrapper<User> wrapper = new QueryWrapper<User>();
  63.         wrapper.eq("mobile",phone);
  64.         User user = this.userMapper.selectOne(wrapper);
  65.         //判断
  66.         if(user==null){
  67.             //如果查询结果为空表示为新用户，就把用户信息注册到数据库
  68.             user = new User();
  69.             user.setMobile(phone);
  70.             user.setPassword(DigestUtils.md5Hex("123456"));//设置初始密码时加密
  71.             //将数据添加到数据库
  72.             this.userMapper.insert(user);
  73.             //是新用户就把标记改为true
  74.             isNew = true;
  75.         }
  76.         //不管是不是新用户都要生成token
  77.         //将数据表中的id生成token
  78.         Map<String,Object> claims = new HashMap<String,Object>();
  79.         claims.put("id",user.getId());
  81.         String jwt = Jwts.builder()
  82.                 .setClaims(claims)
  83.                 .signWith(SignatureAlgorithm.HS256, secret)
  84.                 .setExpiration(new DateTime().plusHours(12).toDate())
  85.                 .compact();
  87.         try {
  88.             //通过rocketMQ将用户已经登录的消息发送给各个服务器
  90.             //封装消息数据
  91.             Map<String,Object>mes = new HashMap<String,Object>();
  92.             mes.put("id",user.getId());
  93.             mes.put("date",System.currentTimeMillis());
  94.             this.rocketMQTemplate.convertAndSend("tanhua-sso-login",mes);
  95.         } catch (MessagingException e) {
  96.             //e.printStackTrace();
  97.             log.error("发送消息失败",e);
  98.         }
  101.         return jwt+"|"+isNew;
  102.     }
  103. }

3.7.4、测试

1564300534797.png

4、总结

4.1 、用到的技术——sso（单点登录技术）

（1）与数据库交互的mapper层用到了mybatis-plus，加强了mybatis的开发效率
（2）service层用到了阿里云的短信服务技术，实现登录验证码的发送，并且结合redis，将验证码临时的进行存储。
还用到了rocketMQ技术，。用户登录验证时用到了jwt技术，实现了对用户的基础信息进行盐加密生成token，而token实现了用户每次访问不同的功能模块时，不需要再次登录。

4.2 、整个单点登录的流程总结

（1）用户注册：用户通过手机号进行注册账号，我们拿到手机号先查询redis中有没有发给该手机号的验证码，如果有则直接返回（错误）提示信息，说验证码已经发过，而且还没有失效，如果redis中没有就调用发送验证码的方法进行发送验证码。然后判断是否成功的发送了验证码，如果返回的验证码为空，则直接返回（错误）信息，说发送验证码失败，请重试，如果成功的发送了验证码，则将验证码存入redis中设置有效时间为n分钟，最后返回null，因为没有错误。
（2）用户登录 ：用户拿到验证码后，第一次根据手机号和验证码进行登录，我们拿到用户的手机号和验证码后，先拿验证那去redis中进行核对，如果redis中没有或和用户传过来的验证码不一致，则返回空，为空的话controller层直接返回错误信息给前端，如果redis中有而且跟用户传来的验证码一致，则判断是不是新用户，是新用户则将用户信息存入数据库，不是则不存，然后生成token，再然后通过rocketMQ将消息发送给各个服务器，最后返回token和isNew