登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›用户中心——比如：腾讯的QQ账号可以登录到很多应用当中 ...

用户中心——比如：腾讯的QQ账号可以登录到很多应用当中

蔓好 前天 22:02
用户中心——比如：腾讯的QQ账号可以登录到很多应用当中

@
目录

  • 用户中心——比如：腾讯的QQ账号可以登录到很多应用当中
  • 管理用户信息，用户管理——通用
  • node.js 的安装 >= 14

    • 启动项目的注意事项：

  • Ant Design  Pro

    • 开启 Umi UI

  • 瘦身
  • 配置后端
  • 数据库设计

    • Mabiats-Plus 驼峰下划线原因报错

  • 用户注册逻辑
  • 用户登录逻辑

    • 如何知道是哪个用户登录了

  • 控制层 Controller 封装请求：
  • 用户管理接口
  • 最后：

管理用户信息，用户管理——通用

node.js 的安装 >= 14

Ant Design Pro 的官方文档地址： https://pro.ant.design/zh-CN/docs/getting-started
  1. # 使用 npm
  2. npm i @ant-design/pro-cli -g
  3. pro create myapp
复制代码
这里我采用的是安装： Ant Design  Pro v2
https://v2-pro.ant.design/docs/getting-started-cn
同时注意配置 Node 对应的环境变量信息。
本地开发：
安装依赖。
  1. npm install  # 安装相关的依赖
复制代码
如果网络状况不佳，可以使用 cnpm 进行加速。
  1. npm run start  # 启动项目
复制代码
启动项目的注意事项：

2.png
  1. "start": "cross-env UMI_ENV=dev max dev",
  2. "start:dev": "cross-env REACT_APP_ENV=dev MOCK=none UMI_ENV=dev max dev",
  3. "start:no-mock": "cross-env MOCK=none UMI_ENV=dev max dev",
  4. "start:pre": "cross-env REACT_APP_ENV=pre UMI_ENV=dev max dev",
  5. "start:test": "cross-env REACT_APP_ENV=test MOCK=none UMI_ENV=dev max dev",
复制代码

  • start:dev 开发模式启动项目：是没有默认的用户和账号的，是无法登录成功的。
  • start 启动项目：含有默认的用户和账号，就是账号： admin user ； 密码为：ant.design
由于 Ant Desgin Pro 版本的更新：这里我们使用的方式是：
通过先从 github，拷贝一份下来，然后再执行 npm install 的方式：
参考文档如下：Ant Design Pro 安装和配置指南-CSDN博客
GitHub 对应的地址：Forbidden · GitHub
3.png

Ant Design  Pro
  1. E:\Java\project\用户中心项目>yarn create umi myapp
复制代码
yarn 包管理器 “样”和 npm 差不多，比 npm 更快一些
  1. yarn -v
复制代码
yarn 的安装；百度
或者是
  1. npm i yarn -g
复制代码
初始化项目
  1. yarn create umi myapp
复制代码
package.json 当中有一个 dependencies 当中记录了我们所需要的所有依赖内容。
所以直接用 yarn 就可以读取到这个内容上依赖内容了，就可以自动安装上相关的依赖了。
start:dev 无法登录 mock=none 就是没有数据了，没有后台，就无法登录了。
开启 Umi UI

安装 Umi UI
  1. yarn add @umijs/preset-ui -D
复制代码
就是一个 git pull 拉取
yarn 的安装教程
瘦身


  • 移除国际化：i18n-remove  国际化 18 个单词 local 删除
4.png


  • e2e 测试——删除
  • DashboardAnalysis 数据——删除
补充：eslintrc.js 是一个代码格式，防止写烂代码
5.png

6.png

配置后端

MySQL5.7
快速初始化：SpringBoot 项目，三种方式

  • gitHub : springboot-templates 模板 拉取（不建议，可能存在不好的代码），而且可能你是在后面才发现
  • 使用 Spring Boot 官方模板生成器：https://start.spring.io/
  • 直接在 IDEA 开发工具中生成
如果要引入java的包，可以去 maven 中心仓库寻找（http://mvnrepository.com/))


  • Spring Boot DevTools 热更新，就是我们修改了代码，会自动更新重启项目
  • Spring Configuration Processor 读取配置文件时有用的


  • Spring 依赖注入框架，帮助你管理 Java 对象，集成一些其它的内容
  • SpringMVC web 框架，提供接口访问，restful 接口等能力
  • Mybaits Java 操作数据库的框架，持久层框架，对 jdbc 的封装
  • mybatis-plus 对 mybaits 的增强，不用写 sql 也能实现增删改查
  • SpringBoot（不用自己管理 Spring 配置，不用自己整合各种框架，快速启动/快速集成项目，不用自己整合各种框架）。比如：Spring,SpringMVC Mybaits 的工具，Spring Boot 就是对它们进行自动组装，集成一个开关(Spring Boot 就是一个开关 Logo)，快速启动
Spring 的单元测试：

  • 在测试类上添加： @ RunWith(SpringRunner.class)注解
  • 在测试方法上使用 @ Test当中是 org.junit.jupiter.api包下的 Test 就可以，自动帮我们启动 spring Boot 当中的项目类了。
7.png

8.png

9.png

10.png

11.png

在 pom.xml 文件当中导入相关的 xml文件信息
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         spring-boot-starter-parent</artifactId>
  8.         <version>2.6.4</version>
  9.         <relativePath/>
  10.     </parent>
  11.     <groupId>com.rainbowsea</groupId>
  12.     user-center</artifactId>
  13.     <version>0.0.1-SNAPSHOT</version>
  14.     <name>user-center</name>
  15.     <description>Demo project for Spring Boot</description>
  16.     <url/>
  17.     <licenses>
  18.         <license/>
  19.     </licenses>
  20.     <developers>
  21.         <developer/>
  22.     </developers>
  23.     <scm>
  24.         <connection/>
  25.         <developerConnection/>
  26.         <tag/>
  27.         <url/>
  28.     </scm>
  29.     <properties>
  30.         <java.version>1.8</java.version>
  31.     </properties>
  32.     <dependencies>
  33.         <dependency>
  34.             <groupId>org.springframework.boot</groupId>
  35.             spring-boot-starter-web</artifactId>
  36.         </dependency>
  37.         <dependency>
  38.             <groupId>org.mybatis.spring.boot</groupId>
  39.             mybatis-spring-boot-starter</artifactId>
  40.             <version>2.2.2</version>
  41.         </dependency>
  43.         <dependency>
  44.             <groupId>com.baomidou</groupId>
  45.             mybatis-plus-boot-starter</artifactId>
  46.             <version>3.5.1</version>
  47.         </dependency>
  49.         <dependency>
  50.             <groupId>org.springframework.boot</groupId>
  51.             spring-boot-devtools</artifactId>
  52.             <scope>runtime</scope>
  53.             <optional>true</optional>
  54.         </dependency>
  61.         
  62.         <dependency>
  63.             <groupId>mysql</groupId>
  64.             mysql-connector-java</artifactId>
  65.             <version>8.0.28</version>
  66.         </dependency>
  67.         <dependency>
  68.             <groupId>org.springframework.boot</groupId>
  69.             spring-boot-configuration-processor</artifactId>
  70.             <optional>true</optional>
  71.         </dependency>
  72.         <dependency>
  73.             <groupId>org.projectlombok</groupId>
  74.             lombok</artifactId>
  75.             <optional>true</optional>
  76.         </dependency>
  77.         <dependency>
  78.             <groupId>org.springframework.boot</groupId>
  79.             spring-boot-starter-test</artifactId>
  80.             <scope>test</scope>
  81.         </dependency>
  82.         <dependency>
  83.             <groupId>org.mybatis.spring.boot</groupId>
  84.             mybatis-spring-boot-starter-test</artifactId>
  85.             <version>3.0.4</version>
  86.             <scope>test</scope>
  87.         </dependency>
  88.     </dependencies>
  90.     <build>
  91.         <plugins>
  92.             <plugin>
  93.                 <groupId>org.apache.maven.plugins</groupId>
  94.                 maven-compiler-plugin</artifactId>
  95.                 <configuration>
  96.                     
  97.                         <path>
  98.                             <groupId>org.springframework.boot</groupId>
  99.                             spring-boot-configuration-processor</artifactId>
  100.                         </path>
  101.                         <path>
  102.                             <groupId>org.projectlombok</groupId>
  103.                             lombok</artifactId>
  104.                         </path>
  105.                     </annotationProcessorPaths>
  106.                 </configuration>
  107.             </plugin>
  108.             <plugin>
  109.                 <groupId>org.springframework.boot</groupId>
  110.                 spring-boot-maven-plugin</artifactId>
  111.                 <configuration>
  112.                     <excludes>
  113.                         <exclude>
  114.                             <groupId>org.projectlombok</groupId>
  115.                             lombok</artifactId>
  116.                         </exclude>
  117.                     </excludes>
  118.                 </configuration>
  119.             </plugin>
  120.         </plugins>
  121.     </build>
  122.     <repositories>
  123.         <repository>
  124.             <id>spring-snapshots</id>
  125.             <name>Spring Snapshots</name>
  126.             <url>https://repo.spring.io/snapshot</url>
  127.             <releases>
  128.                 <enabled>false</enabled>
  129.             </releases>
  130.         </repository>
  131.     </repositories>
  132.     <pluginRepositories>
  133.         <pluginRepository>
  134.             <id>spring-snapshots</id>
  135.             <name>Spring Snapshots</name>
  136.             <url>https://repo.spring.io/snapshot</url>
  137.             <releases>
  138.                 <enabled>false</enabled>
  139.             </releases>
  140.         </pluginRepository>
  141.     </pluginRepositories>
  143. </project>
复制代码
补充上：Junit 用于测试使用
12.png
  1. <dependency>
  2.     <groupId>junit</groupId>
  3.     junit</artifactId>
  4.     <version>4.12</version>
  5.     <scope>test</scope>
  6. </dependency>
复制代码
数据库设计

使用 IDEA 默认的工具，连接上本地数据库：
13.png

14.png

15.png

16.png


18.png
  1. create table user
  2. (
  3.     username     varchar(256)                       null comment '用户昵称',
  4.     id           bigint auto_increment comment 'id'
  5.         primary key,
  6.     userAccount  varchar(256)                       null comment '账号',
  7.     avatarUrl    varchar(1024)                      null comment '用户头像',
  8.     gender       tinyint                            null comment '性别',
  9.     userPassword varchar(512)                       not null comment '密码',
  10.     phone        varchar(128)                       null comment '电话',
  11.     email        varchar(512)                       null comment '邮箱',
  12.     userStatus   int      default 0                 not null comment '状态-0-正常',
  13.     createTime   datetime default CURRENT_TIMESTAMP null comment '创建时间',
  14.     updateTime   datetime default CURRENT_TIMESTAMP null comment '更新时间',
  15.     isDelete     tinyint  default 0                 not null comment '是否删除 0 1（逻辑删除）'
  16. )
  17.     comment '用户';
复制代码
  1. id（主键）bigint
  2. username 昵称  varchar
  3. userAccount 登录账号
  4. avatarUrl 头像 varchar
  5. gender 性别 tinyint
  6. userPassword 密码  varchar
  7. phone 电话 varchar
  8. email 邮箱 varchar
  9. userStatus 用户状态 int  0 - 正常
  10. createTime 创建时间（数据插入时间）datetime
  11. updateTime 更新时间（数据更新时间）datetime
  12. isDelete 是否删除 0 1（逻辑删除）tinyint
  13. userRole 用户角色 0 - 普通用户 1 - 管理员
复制代码

  • 业务上的删除，和与业务无关上的删除
MySQL 添加默认时间，两个默认时间
模型 user 对象-> 和数据库的字段关联上，使用自动生成，MyBatix（Enadled)
Actual Column 生成实体对象的属性是一致的勾选上的话
测试“包”尽量和开发的“包”保持一致，不然，有时路径包的不同，可能存在错误。
Springboot 测试类(@ Test org.junit.jupitor.api.Test)
19.png
  1. package com.rainbowsea.usercenter.service;
  4. import com.rainbowsea.usercenter.model.User;
  5. import org.junit.jupiter.api.Assertions;
  6. import org.junit.jupiter.api.Test;
  7. import org.springframework.boot.test.context.SpringBootTest;
  9. import javax.annotation.Resource;
  10. import java.lang.String;
  12. @SpringBootTest
  13. public class UserServiceTest {
  15.     @Resource
  16.     private UserService userService;
  18.     @Test
  19.     public void testAdduser() {
  20.         User user = new User();
  21.         user.setUsername("dogYupi");
  22.         user.setUserAccount("123");
  23.         user.setAvatarUrl("https://profile-avatar.csdnimg.cn/2f8ef0ed68a647bcad04088152e00c69_weixin_61635597.jpg!1");
  24.         user.setGender(0);
  25.         user.setUserPassword("123456");
  26.         user.setPhone("123");
  27.         user.setEmail("456");
  29.         boolean result = userService.save(user);
  30.         System.out.println(user.getId());
  31.         Assertions.assertTrue(result);
  34.     }
  35. }
复制代码
插件 ( Generate All setter Enalbed 生成 set 方法，进行赋值）
MyBatisX IDEA 插件的详细使用：
20.png

21.png

22.png

23.png

24.png

25.png

26.png

IDEA  GenerateAllSetter
27.png

28.png

29.png

Mabiats-Plus 驼峰下划线原因报错
  1. map-underscore-to-conmel-case : false
  2. # 默认是 true 表示开启了 将数据表当中的下划线转换为了驼峰映射。
  3. 如果你的数据库已经是驼峰命名了字段，那么就需要设置为 false 不然，会报错找不到
复制代码
30.png

prsf 可以快速打出常量；
限流，在某一台 IP，登录太多了，就限制一下。不过做过度设计。
Sl4fi 是 在 Lomack 当中的，log.inof("建议用英文，这样可以使用任何接口读取 日志，不会有中文乱码")
用户注册逻辑

注册逻辑：

  • 校验用户账号和密码是否合法。
  • 非空
  • 账号长度不小于 4 位
  • 密码就不小于 8 位
  • 账号不包含特殊字符
  • 校验密码是否输入正确，要和数据库中的密文密码去对比，密码就是需要加密，永远不需要对密码解密的操作。
  • 用户脱敏，隐藏敏感信息，防止数据库中的字段泄露
  • 我们要记录用户的登录态(session)，将其存到服务器上（用后端 Spring Boot 框架封装的服务器 tomcat 去记录） cookie
  • 返回脱敏后的用户信息。
  • 特别的： 当校验的过程中存在查询数据库，连接数据库，将其验证放入到校验的最后面，因为连接数据库所消耗的资源，比较大，所以将其放后面。
用户 脱敏
不脱敏的话，你返回给前端的数据就是，实实在在从后端库当中拿取到的，一些敏感的数据了，脱敏这里：新 new 一个对象，重新 set 设置，你要返回给前端的信息即可，不想返回的，set 设置为 默认的即可。
补充：commons-lang3 工具类，用于对内容上的校验：
该类当中封装了，需要有用的工具类。比如：这里使用上的：
31.png

32.png

  1. <dependency>
  2.     <groupId>org.apache.commons</groupId>
  3.     commons-lang3</artifactId>
  4.     <version>3.12.0</version>
  5. </dependency>
复制代码
  1. package com.rainbowsea.usercenter.service.impl;
  3. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
  4. import com.rainbowsea.usercenter.model.User;
  5. import com.rainbowsea.usercenter.service.UserService;
  6. import com.rainbowsea.usercenter.mapper.UserMapper;
  7. import org.apache.commons.lang3.StringUtils;
  8. import org.springframework.stereotype.Service;
  10. /**
  11. * @author huo
  12. * @description 针对表【user(用户)】的数据库操作Service实现
  13. * @createDate 2025-04-14 16:03:21
  14. */
  15. @Service
  16. public class UserServiceImpl extends ServiceImpl<UserMapper, User>
  17.         implements UserService {
  19.     @Override
  20.     public long userRegister(String userAccount, String userPassword, String chekcPassword) {
  23.         // 1. 校验
  24.         if (StringUtils.isAllBlank(userAccount, userPassword, chekcPassword)) {
  25.             return -1;
  26.         }
  27.         return 0;
  28.     }
  29. }
复制代码
密码必须加密，不可以明文存储，必须加密，并且永远不需要对密码解密。这里我们使用的加密工具是一个 **DigestUtils** 工具类。是在 org.springframework.util.DigestUtils。
33.png
  1. import org.springframework.util.DigestUtils;
  3.     @org.junit.Test
  4.     public void testDigest() {
  5.         String newPassword = DigestUtils.md5DigestAsHex(("rainbowsea" + "123").getBytes());
  6.         System.out.println(newPassword);
  7.     }
复制代码
账户不能有特殊字符，这里我们使用的正则表达式，使用的是 **matches()** 它是 String  当中的方法。
  1.     @org.junit.Test
  2.     public  void testMatches() {
  3.         // 正则表达式匹配字母、数字、下划线
  4.         String regex = "^[a-zA-Z0-9_]+$";
  5.         // matches() 满足正则表达式，则返回 true，否则返回 false
  6.         System.out.println("889tttt!!!!".matches(regex));
  7.         System.out.println("889tt".matches(regex));
  8.     }
  9. }
复制代码
34.png

密码必须加密，不可以明文存储，加盐（让密码更混乱一些），永远不需要对密码进行解密
35.png


  • 数据库的查询校验，可以放置到校验的最后面(或者比较后面)，让前面的校验通过了，再走（数据库查询的校验），不然，前面不走数据的校验都没通过，而你数据库查询更耗费资源。
  • 可以尽量减少使用 if-else ，而是使用 (!if) 进入 return -1 返回的形式。
初始验证用户注册的逻辑代码实现：
  1. package com.rainbowsea.usercenter.service.impl;
  3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  4. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
  5. import com.rainbowsea.usercenter.model.User;
  6. import com.rainbowsea.usercenter.service.UserService;
  7. import com.rainbowsea.usercenter.mapper.UserMapper;
  8. import org.apache.commons.lang3.StringUtils;
  9. import org.springframework.stereotype.Service;
  10. import org.springframework.util.DigestUtils;
  12. /**
  13. * @author huo
  14. * @description 针对表【user(用户)】的数据库操作Service实现
  15. * @createDate 2025-04-14 16:03:21
  16. */
  17. @Service
  18. public class UserServiceImpl extends ServiceImpl<UserMapper, User>
  19.         implements UserService {
  21.     // 加盐
  22.     private static final String SALT = "rainbowsea";
  24.     @Override
  25.     public long userRegister(String userAccount, String userPassword, String chekcPassword) {
  28.         // 1. 校验
  29.         if (StringUtils.isAllBlank(userAccount, userPassword, chekcPassword)) {
  30.             return -1;
  31.         }
  32.         // 账号长度不小于 4 位 ，不能大于 128
  33.         if (userAccount.length() < 4 || userAccount.length() > 128) {
  34.             return -1;
  35.         }
  37.         //  密码就不小于 8 位 , 注意两个还有一个校验密码
  38.         if (userPassword.length() < 8 || chekcPassword.length() < 8) {
  39.             return -1;
  40.         }
  41.         // 账号不包含特殊字符
  42.         // 正则表达式匹配字母、数字、下划线
  43.         String regex = "^[a-zA-Z0-9_]+$";
  44.         boolean matcher = userAccount.matches(regex);
  45.         //  matches() 满足正则表达式，则返回 true，否则返回 false
  46.         if (!matcher) {
  47.             return -1;
  48.         }
  51.         // 账号不可重复，这里查询数据库，一般将其放在最后面，当前面的校验都没通过，
  52.         QueryWrapper<User> queryWrapper = new QueryWrapper<>();
  53.         queryWrapper.eq("userAccount", userAccount);
  54.         long count = this.count(queryWrapper);  // 查询到就大于 0
  55.         if (count > 0) {
  56.             return -1;
  57.         }
  59.         // 密码和校验密码相同
  60.         if (!userPassword.equals(chekcPassword)) {
  61.             return -1;
  62.         }
  63.         // 密码加密+加盐
  64.         String encryptPassword = DigestUtils.md5DigestAsHex((SALT + userPassword).getBytes());
  66.         // 校验通过插入数据
  67.         User user = new User();
  68.         user.setUserAccount(userAccount);
  69.         user.setUserPassword(encryptPassword);
  70.         boolean saveResult = this.save(user);
  71.         if (!saveResult) {
  72.             return -1;
  73.         }
  75.         return user.getId();
  76.     }
  77. }
复制代码
36.png

对应的测试验证测试：
  1. import org.junit.jupiter.api.Test;
  4. @Test
  5.     public void userRegister() {
  6.         User user = new User();
  8.         // 验证密码不为空
  9.         String userAccount = "dogYupi";
  10.         String userPassword = "";
  11.         String checkPassword = "12345678";
  12.         long result = userService.userRegister(userAccount, userPassword, checkPassword);
  13.         Assertions.assertEquals(-1, result);
  15.         // 测试账户长度不能小于  4
  16.         userAccount = "yu";
  17.         userPassword = "12345678";
  18.         result = userService.userRegister(userAccount, userPassword, checkPassword);
  19.         Assertions.assertEquals(-1, result);
  22.         // 验证账户不可以重复
  23.         userAccount = "dogYupi";
  24.         userPassword = "12345678";
  25.         result = userService.userRegister(userAccount, userPassword, checkPassword);
  26.         Assertions.assertEquals(-1, result);
  29.         //  验证账户不包含特殊字符
  30.         userAccount = "yu pi";
  31.         result = userService.userRegister(userAccount, userPassword, checkPassword);
  32.         Assertions.assertEquals(-1, result);
  35.         // 验证密码和校验密码不一致
  36.         checkPassword = "123456789";
  37.         result = userService.userRegister(userAccount, userPassword, checkPassword);
  38.         Assertions.assertEquals(-1, result);
  40.         // 验证密码不小于 8 位
  41.         userPassword = "123";
  42.         result = userService.userRegister(userAccount, userPassword, checkPassword);
  43.         Assertions.assertEquals(-1, result);
  45.         // 验证密码不为空
  46.         userAccount = "rainbowsea";
  47.         userPassword = "12345678";
  48.         checkPassword = "12345678";
  49.         result = userService.userRegister(userAccount, userPassword, checkPassword);
  50.         Assertions.assertTrue(result > 0);
  51.         //Assertions.assertTrue( result > 0);
  53.     }
复制代码
用户登录逻辑


  • 校验用户账户和密码是否合法

    • 非空判断
    • 账户长度 不小于 4 位数，不可以大于 128 位数
    • 密码 不小于 8 位数
    • 账户不包含特殊字符

  • 校验密码是否输入正确，要和数据库中的密文密码去对比。
  • 我们需要记录用户的登录态(session)，将其存储到服务器上（用后端 Spring Boot 框架封装的服务器 tomcat 去记录  cookile）
  • 返回用户的信息给前端，需要注意的是，这里我们需要将返回的数据进行一个脱敏操作，返回给我们想要给前端用户的信息，其它的信息，不需要返回给前端，也不可以让前端拿到。
用户脱敏
不脱敏的话，你返回给前端的数据就是，实实在在从后端库当中拿取到的，一些敏感的数据了，脱敏这里：新 new 一个对象，重新 set 设置，你要返回给前端的信息即可，不想返回的，set 设置为 默认的即可。
密码加密+加盐，注意:你查询密码的时候，因为你的当时插入数据是怎么加密的，你查询对面的时候也是怎么加密的, 因为你在数据库当中存储的是你加密的密码，用的是对称加密。
如何知道是哪个用户登录了

Java  Web 这一块的知识内容

  • 连接服务器端后，可以得到一个 session 状态(这里可以使用 匿名会话)，返回给前端。
  • 登录成功后，得到了登录成功的 session 状态，并且给该 session 设置一些值(比如用户信息)，session 相当类比于一个 Map 集合(对应着 key-value 键值对)，返回给前端一个设置 cookie 的”命令/信息“
sessioin => cookie

  • 前端接收到后端等的命令后，设置 cookie ,保存到浏览器内
  • 前端再次请求后端的时候（相同的域名，这里存在一个跨域问题），在请求头中带上对应的  cookie 去请求。
  • 后端拿到前端传来的 cookie ，找到对应的  session
  • 后端从 session 中可以取出基于该 session 存储的变量（用户的登录信息，登录名一些你想给前端的信息内容）
37.png
  1. @Service
  2. @Slf4j
  3. public class UserServiceImpl extends ServiceImpl<UserMapper, User>
  4.         implements UserService {
  6.     /**
  7.      * 加盐 混淆，让密码更加没有规律，更加安全一些
  8.      */
  9.     private static final String SALT = "rainbowsea";
  12.     /**
  13.      * 用户登录态
  14.      */
  15.     private static final String USER_LOGIN_STATE = "userloginstate";
  16.     @Resource
  17.     private UserMapper userMapper;
  20. @Override
  21.     public User doLogin(String userAccount, String userPassword, HttpServletRequest request) {
  23.         // 1. 校验
  24.         if (StringUtils.isAllBlank(userAccount, userPassword)) {
  25.             return null;
  26.         }
  27.         // 账号长度不小于 4 位 ，不能大于 128
  28.         if (userAccount.length() < 4 || userAccount.length() > 128) {
  29.             return null;
  30.         }
  32.         //  密码就不小于 8 位
  33.         if (userPassword.length() < 8) {
  34.             return null;
  35.         }
  36.         // 账号不包含特殊字符
  37.         // 正则表达式匹配字母、数字、下划线
  38.         String regex = "^[a-zA-Z0-9_]+$";
  39.         boolean matcher = userAccount.matches(regex);
  40.         //  matches() 满足正则表达式，则返回 true，否则返回 false
  41.         if (!matcher) {
  42.             return null;
  43.         }
  46.         // 密码加密+加盐，注意:你查询密码的时候，因为你的当时插入数据是怎么加密的，你查询对面的时候也是怎么加密的
  47.         String encryptPassword = DigestUtils.md5DigestAsHex((SALT + userPassword).getBytes());
  48.         QueryWrapper<User> queryWrapper = new QueryWrapper<>();
  49.         queryWrapper.eq("userAccount",userAccount);
  50.         queryWrapper.eq("userPassword",userPassword);  // 注意：这里的字段名是数据库当中对应的字段名，不可以随便写
  51.         User user = userMapper.selectOne(queryWrapper);
  52.         if(user == null) {
  53.             log.info("user login failed, userAccount cannot userPassword");
  54.             return null;
  55.         }
  59.         // 3.用户脱敏
  60.         User safeUser = new User();
  61.         safeUser.setId(user.getId());
  62.         safeUser.setUsername(user.getUsername());
  63.         safeUser.setUserAccount(user.getUserAccount());
  64.         safeUser.setAvatarUrl(user.getAvatarUrl());
  65.         safeUser.setGender(user.getGender());
  66.         safeUser.setPhone(user.getPhone());
  67.         safeUser.setEmail(user.getEmail());
  68.         safeUser.setUserStatus(user.getUserStatus());
  69.         safeUser.setCreateTime(user.getCreateTime());
  70.         safeUser.setUpdateTime(user.getUpdateTime());
  73.         // 4. 记录用户的登录态
  74.         request.getSession().setAttribute(USER_LOGIN_STATE,user);
  76.         return safeUser;
  77.     }
  79. }
复制代码
// todo 修改为自定义异常。
MyBatis-plus 的逻辑删除设置：
逻辑删除支持
38.png

39.png
  1. mybatis-plus:
  2.   global-config:
  3.     db-config:
  4.       logic-delete-field: deleted # 全局逻辑删除字段名
  5.       logic-delete-value: 1 # 逻辑已删除值
  6.       logic-not-delete-value: 0 # 逻辑未删除值
复制代码
  1. import com.baomidou.mybatisplus.annotation.TableLogic;
  3. public class User {
  4.     // 其他字段...
  6.     @TableLogic
  7.     private Integer deleted;
  8. }
复制代码
auto filling java call 自动添加 Java 方法参数；
40.png

用户注册接口

  • 接收参数：用户账户，密码
  • 请求类型：POST
  • 请求体：JSON 格式的数据
请求参数很长时，不建议使用 GET 请求

  • 返回值：用户信息（脱敏）
这里我们定义一个，用户注册的一个请求体。
作用：就是当用户发送请求过来，可以将用户在前端发送的信息，转换为我们设置配置设置的一个 用户注册请求体。
41.png

  1. package com.rainbowsea.usercenter.model.request;
  4. import lombok.AllArgsConstructor;
  5. import lombok.Data;
  6. import lombok.NoArgsConstructor;
  8. import java.io.Serializable;
  11. /**
  12. * 用户注册请求体, 用于封装用户发送的请求，将其转换为 Java对象使用
  13. */
  14. @Data
  15. @NoArgsConstructor
  16. @AllArgsConstructor
  17. public class UserRegisterRequest implements Serializable {
  18.     private static final long serialVersionUID = 504278674381074669L;
  20.     private String userAccount;
  21.     private String userPassword;
  22.     private String checkPassword;
  23. }
复制代码
42.png

用户注册和登录校验逻辑完整代码：
  1. package com.rainbowsea.usercenter.service.impl;
  2. import java.util.Date;
  4. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  5. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
  6. import com.rainbowsea.usercenter.model.User;
  7. import com.rainbowsea.usercenter.service.UserService;
  8. import com.rainbowsea.usercenter.mapper.UserMapper;
  9. import lombok.extern.slf4j.Slf4j;
  10. import org.apache.commons.lang3.StringUtils;
  11. import org.springframework.stereotype.Service;
  12. import org.springframework.util.DigestUtils;
  14. import javax.annotation.Resource;
  15. import javax.servlet.http.HttpServletRequest;
  17. /**
  18. * @author huo
  19. * @description 针对表【user(用户)】的数据库操作Service实现
  20. * @createDate 2025-04-14 16:03:21
  21. */
  22. @Service
  23. @Slf4j
  24. public class UserServiceImpl extends ServiceImpl<UserMapper, User>
  25.         implements UserService {
  27.     /**
  28.      * 加盐 混淆，让密码更加没有规律，更加安全一些
  29.      */
  30.     private static final String SALT = "rainbowsea";
  33.     /**
  34.      * 用户登录态
  35.      */
  36.     private static final String USER_LOGIN_STATE = "userloginstate";
  37.     @Resource
  38.     private UserMapper userMapper;
  40.     @Override
  41.     public long userRegister(String userAccount, String userPassword, String chekcPassword) {
  44.         // 1. 校验
  45.         if (StringUtils.isAllBlank(userAccount, userPassword, chekcPassword)) {
  46.             return -1;
  47.         }
  48.         // 账号长度不小于 4 位 ，不能大于 128
  49.         if (userAccount.length() < 4 || userAccount.length() > 128) {
  50.             return -1;
  51.         }
  53.         //  密码就不小于 8 位 , 注意两个还有一个校验密码
  54.         if (userPassword.length() < 8 || chekcPassword.length() < 8) {
  55.             return -1;
  56.         }
  57.         // 账号不包含特殊字符
  58.         // 正则表达式匹配字母、数字、下划线
  59.         String regex = "^[a-zA-Z0-9_]+$";
  60.         boolean matcher = userAccount.matches(regex);
  61.         //  matches() 满足正则表达式，则返回 true，否则返回 false
  62.         if (!matcher) {
  63.             return -1;
  64.         }
  67.         // 账号不可重复，这里查询数据库，一般将其放在最后面，当前面的校验都没通过，
  68.         QueryWrapper<User> queryWrapper = new QueryWrapper<>();
  69.         queryWrapper.eq("userAccount", userAccount);
  70.         long count = this.count(queryWrapper);  // 查询到就大于 0
  71.         if (count > 0) {
  72.             return -1;
  73.         }
  75.         // 密码和校验密码相同
  76.         if (!userPassword.equals(chekcPassword)) {
  77.             return -1;
  78.         }
  79.         // 密码加密+加盐
  80.         String encryptPassword = DigestUtils.md5DigestAsHex((SALT + userPassword).getBytes());
  82.         // 校验通过插入数据
  83.         User user = new User();
  84.         user.setUserAccount(userAccount);
  85.         user.setUserPassword(encryptPassword);
  86.         boolean saveResult = this.save(user);
  87.         if (!saveResult) {
  88.             return -1;
  89.         }
  91.         return user.getId();
  92.     }
  94.     @Override
  95.     public User userLogin(String userAccount, String userPassword, HttpServletRequest request) {
  97.         // 1. 校验
  98.         if (StringUtils.isAllBlank(userAccount, userPassword)) {
  99.             return null;
  100.         }
  101.         // 账号长度不小于 4 位 ，不能大于 128
  102.         if (userAccount.length() < 4 || userAccount.length() > 128) {
  103.             return null;
  104.         }
  106.         //  密码就不小于 8 位
  107.         if (userPassword.length() < 8) {
  108.             return null;
  109.         }
  110.         // 账号不包含特殊字符
  111.         // 正则表达式匹配字母、数字、下划线
  112.         String regex = "^[a-zA-Z0-9_]+$";
  113.         boolean matcher = userAccount.matches(regex);
  114.         //  matches() 满足正则表达式，则返回 true，否则返回 false
  115.         if (!matcher) {
  116.             return null;
  117.         }
  120.         // 密码加密+加盐，注意:你查询密码的时候，因为你的当时插入数据是怎么加密的，你查询对面的时候也是怎么加密的
  121.         String encryptPassword = DigestUtils.md5DigestAsHex((SALT + userPassword).getBytes());
  122.         QueryWrapper<User> queryWrapper = new QueryWrapper<>();
  123.         queryWrapper.eq("userAccount",userAccount);
  124.         queryWrapper.eq("userPassword",userPassword);  // 注意：这里的字段名是数据库当中对应的字段名，不可以随便写
  125.         User user = userMapper.selectOne(queryWrapper);
  126.         if(user == null) {
  127.             log.info("user login failed, userAccount cannot userPassword");
  128.             return null;
  129.         }
  133.         // 3.用户脱敏
  134.         User safeUser = new User();
  135.         safeUser.setId(user.getId());
  136.         safeUser.setUsername(user.getUsername());
  137.         safeUser.setUserAccount(user.getUserAccount());
  138.         safeUser.setAvatarUrl(user.getAvatarUrl());
  139.         safeUser.setGender(user.getGender());
  140.         safeUser.setPhone(user.getPhone());
  141.         safeUser.setEmail(user.getEmail());
  142.         safeUser.setUserStatus(user.getUserStatus());
  143.         safeUser.setCreateTime(user.getCreateTime());
  144.         safeUser.setUpdateTime(user.getUpdateTime());
  147.         // 4. 记录用户的登录态
  148.         request.getSession().setAttribute(USER_LOGIN_STATE,user);
  150.         return safeUser;
  151.     }
  152. }
复制代码
用户注册控制层 Controller 封装请求：
43.png
  1. package com.rainbowsea.usercenter.controller;
  4. import com.rainbowsea.usercenter.model.request.UserRegisterRequest;
  5. import com.rainbowsea.usercenter.service.UserService;
  6. import org.apache.commons.lang3.StringUtils;
  7. import org.springframework.web.bind.annotation.PostMapping;
  8. import org.springframework.web.bind.annotation.RequestBody;
  9. import org.springframework.web.bind.annotation.RequestMapping;
  10. import org.springframework.web.bind.annotation.RestController;
  12. import javax.annotation.Resource;
  14. @RestController
  15. @RequestMapping("/user")
  16. public class UserController {
  19.     @Resource
  20.     private UserService userService;
  23.     /**
  24.      * 用户注册
  25.      *  // @RequestBody 常用于处理POST请求中的JSON或XML数据，将这些数据转换为Java对象
  26.      * @param userRegisterRequest 用户请求体当中的信息
  27.      * @return RainbowSea
  28.      */
  29.     @PostMapping("/register")
  30.     public Long userRegister(@RequestBody UserRegisterRequest userRegisterRequest) {
  32.         if(userRegisterRequest == null) {
  33.             return null;
  34.         }
  36.         String userAccount = userRegisterRequest.getUserAccount();
  37.         String userPassword = userRegisterRequest.getUserPassword();
  38.         String checkPassword = userRegisterRequest.getCheckPassword();
  40.         if(StringUtils.isAllBlank(userAccount,userPassword,checkPassword)) {
  41.             return null;
  42.         }
  43.         return userService.userRegister(userAccount, userPassword, checkPassword);
  44.     }
  45. }
复制代码
用户登录控制层 Controller 封装请求：
44.png
  1. package com.rainbowsea.usercenter.controller;
  4. import com.rainbowsea.usercenter.model.User;
  5. import com.rainbowsea.usercenter.model.request.UserLoginRequest;
  6. import com.rainbowsea.usercenter.model.request.UserRegisterRequest;
  7. import com.rainbowsea.usercenter.service.UserService;
  8. import org.apache.commons.lang3.StringUtils;
  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 javax.annotation.Resource;
  15. import javax.servlet.http.HttpServletRequest;
  17. @RestController
  18. @RequestMapping("/user")
  19. public class UserController {
  22.     @Resource
  23.     private UserService userService;
  26.     /**
  27.      * 用户登录
  28.      *
  29.      * @param userLoginRequest 用户的登录的请求体，用户登录发送的信息，封装到其中了
  30.      * @param request          用户请求
  31.      * @return RainbowSea
  32.      */
  33.     @PostMapping("/login")
  34.     public User userLogin(@RequestBody UserLoginRequest userLoginRequest, HttpServletRequest request) {
  36.         if (userLoginRequest == null) {
  37.             return null;
  38.         }
  40.         String userAccount = userLoginRequest.getUserAccount();
  41.         String userPassword = userLoginRequest.getUserPassword();
  43.         if (StringUtils.isAllBlank(userAccount, userPassword)) {
  44.             return null;
  45.         }
  47.         return userService.userLogin(userAccount, userPassword, request);
  49.     }
  51. }
复制代码
用户注册和登录-控制层 Controller 封装请求完整：
  1. package com.rainbowsea.usercenter.controller;
  4. import com.rainbowsea.usercenter.model.User;
  5. import com.rainbowsea.usercenter.model.request.UserLoginRequest;
  6. import com.rainbowsea.usercenter.model.request.UserRegisterRequest;
  7. import com.rainbowsea.usercenter.service.UserService;
  8. import org.apache.commons.lang3.StringUtils;
  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 javax.annotation.Resource;
  15. import javax.servlet.http.HttpServletRequest;
  17. @RestController
  18. @RequestMapping("/user")
  19. public class UserController {
  22.     @Resource
  23.     private UserService userService;
  26.     /**
  27.      * 用户登录
  28.      *
  29.      * @param userLoginRequest 用户的登录的请求体，用户登录发送的信息，封装到其中了
  30.      * @param request          用户请求
  31.      * @return RainbowSea
  32.      */
  33.     @PostMapping("/login")
  34.     public User userLogin(@RequestBody UserLoginRequest userLoginRequest, HttpServletRequest request) {
  36.         if (userLoginRequest == null) {
  37.             return null;
  38.         }
  40.         String userAccount = userLoginRequest.getUserAccount();
  41.         String userPassword = userLoginRequest.getUserPassword();
  43.         if (StringUtils.isAllBlank(userAccount, userPassword)) {
  44.             return null;
  45.         }
  47.         return userService.userLogin(userAccount, userPassword, request);
  49.     }
  52.     /**
  53.      * 用户注册
  54.      * // @RequestBody 常用于处理POST请求中的JSON或XML数据，将这些数据转换为Java对象
  55.      *
  56.      * @param userRegisterRequest 用户请求体当中的信息，用户注册时发送的信息，封装到其中了
  57.      * @return RainbowSea
  58.      */
  59.     @PostMapping("/register")
  60.     public Long userRegister(@RequestBody UserRegisterRequest userRegisterRequest) {
  62.         if (userRegisterRequest == null) {
  63.             return null;
  64.         }
  66.         String userAccount = userRegisterRequest.getUserAccount();
  67.         String userPassword = userRegisterRequest.getUserPassword();
  68.         String checkPassword = userRegisterRequest.getCheckPassword();
  70.         if (StringUtils.isAllBlank(userAccount, userPassword, checkPassword)) {
  71.             return null;
  72.         }
  73.         return userService.userRegister(userAccount, userPassword, checkPassword);
  74.     }
  75. }
复制代码
控制层 Controller 封装请求：
  1. @RestController 适用于编写 restful 风格的 api，返回值默认为 json 类型
复制代码
controller 层倾向于对请求参数本身的校验，不涉及业务逻辑本身（越少越好）
service 层是对业务逻辑的校验（有可能被 controller 之外的类调用）
校验，测试，Controller 控制层的逻辑测试
这里我们不使用 postMan ，而是使用 IDEA 自带的一个 HTTP Client工具：
45.png

46.png
  1. ###
  2. GET http://localhost/ajax
  4. ###
  5. POST http://localhost:8080/user/login
  6. Content-Type: application/json
  8. {
  9.   "userAccount": "rainbowsea",
  10.   "userPassword": "12345678"
  11. }
复制代码
注意：需要先将你的微服务，对应微服务启动起来，才可以被使用访问上。
47.png

补充：添加上了；查询用户信息，删除用户的接口。
同时这里我们对数据库重新更新了一下，添加了一个  userRole 角色字段，userRole     int      default 0                 not null comment '用户角色 0- 普通用户 1 - 管理员 2 - vip'
注意：用户角色权限上的管理，这里我们只有 管理员用户才可以执行查询操作，其它用户是不可以执行查询操作的，这里我们在 controller 进行一个代码的编写。
这里我们优化将我们的一个 用户登录态键配置在，这里的 UserService的接口当中，这样我们就可以在多个位置上进行引用该用户登录态键，作为，一个判断用户是否登录的一个操作。
48.png

用户管理接口

！！！必须鉴权

  • 查询用户
  • 删除用户（）
写代码流程：

  • 先做设计
  • 代码实现
  • 持续优化！！！（复用代码，提取公共逻辑/常量）
最后：

“在这个最后的篇章中，我要表达我对每一位读者的感激之情。你们的关注和回复是我创作的动力源泉，我从你们身上吸取了无尽的灵感与勇气。我会将你们的鼓励留在心底，继续在其他的领域奋斗。感谢你们，我们总会在某个时刻再次相遇。”
49.gif


来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
蔓好
前天 22:02

0

粉丝关注

20

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫