博客基础模块开发（登录注册）

博客基础模块开发（登录注册）

目录

• 一、方案编写
• 二、基础环境搭建
• 三、快速体验框架使用
• 四、数据库表构建
• 五、后端API接口实现与测试
• 六、前端代码环境搭建和编写
• 七、前后端联调

一、方案编写

1.1 功能概述

实现博客系统的用户登录和注册功能，包含基础的用户认证、会话管理和安全验证。

1.2 功能需求明细

1.2.1 用户注册功能

1.2.2 用户登录功能

1.2.3 系统优化需求

验证码忽略大小写

// 验证码校验工具类
public class CaptchaValidator {

/**
* 验证验证码（忽略大小写）
* @param inputCode 用户输入的验证码
* @param storeCode 实际存储的验证码
* @return 是否通过验证
*/
public static boolean validateIgnoreCase(String inputCode, String storeCode) {
if (inputCode == null || storeCode == null) {
return false;
}
return inputCode.equalsIgnoreCase(storeCode);
}

/**
* 生成验证码（统一转为大写存储）
*/
public static String generateCode(int length) {
String chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
Random random = new Random();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < length; i++) {
sb.append(chars.charAt(random.nextInt(chars.length())));
}
return sb.toString();
}
}

字体配置更新

# application.yml
blog:
font:
path: /usr/share/fonts/blog/ # Linux服务器路径
# path: C:/Windows/Fonts/blog/ # Windows开发环境
default: Microsoft YaHei.ttf
title-font: FZZJ-HBJW.ttf # 标题字体
content-font: SimSun.ttf # 内容字体

网站基础配置

# application.yml
blog:
site:
title: 我的技术博客
subtitle: 分享编程经验和技术干货
keywords: Java,Spring Boot,Redis,博客
description: 一个专注于后端技术的个人博客
icp: 京ICP备xxxxxx号
author: Your Name
email: your@email.com

seo:
baidu-verify: xxxxxx
google-verify: xxxxxx

个性化主题-追悼模式

/* 追悼模式样式 theme/mourning.css */
.mourning-mode {
filter: grayscale(100%);
-webkit-filter: grayscale(100%);
-moz-filter: grayscale(100%);
-ms-filter: grayscale(100%);
-o-filter: grayscale(100%);
}

.mourning-mode .navbar {
background-color: #333 !important;
}

.mourning-mode .footer {
background-color: #222 !important;
}

.mourning-mode a:hover {
color: #999 !important;
}

// 主题切换逻辑
const ThemeManager = {
// 启用追悼模式
enableMourningMode() {
document.body.classList.add('mourning-mode');
localStorage.setItem('theme', 'mourning');

// 通知后端记录设置
axios.post('/api/user/theme', { theme: 'mourning' });
},

// 禁用追悼模式
disableMourningMode() {
document.body.classList.remove('mourning-mode');
localStorage.setItem('theme', 'normal');
axios.post('/api/user/theme', { theme: 'normal' });
},

// 切换追悼模式
toggleMourningMode() {
if (document.body.classList.contains('mourning-mode')) {
this.disableMourningMode();
} else {
this.enableMourningMode();
}
},

// 初始化主题
initTheme() {
const savedTheme = localStorage.getItem('theme');
if (savedTheme === 'mourning') {
document.body.classList.add('mourning-mode');
}

// 特殊日期自动开启（清明节等）
const today = new Date();
if (this.isMourningDate(today)) {
this.enableMourningMode();
}
},

// 判断是否追悼日期
isMourningDate(date) {
const month = date.getMonth() + 1;
const day = date.getDate();
// 清明节（4月4日或5日）
return (month === 4 && (day === 4 || day === 5)) ||
// 512汶川地震纪念日
(month === 5 && day === 12) ||
// 南京大屠杀纪念日
(month === 12 && day === 13);
}
};

// 页面加载时初始化
document.addEventListener('DOMContentLoaded', () => {
ThemeManager.initTheme();
});

1.3 技术选型

二、基础环境搭建

2.1 Ubuntu 环境搭建

2.1.1 安装 JDK 17

# 更新软件源
sudo apt update

# 安装 OpenJDK 17
sudo apt install openjdk-17-jdk -y

# 验证安装
java -version

# 设置 JAVA_HOME
echo 'export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64' >> ~/.bashrc
echo 'export PATH=$JAVA_HOME/bin:$PATH' >> ~/.bashrc
source ~/.bashrc

2.1.2 安装 MySQL 8.0

# 安装 MySQL
sudo apt install mysql-server-8.0 -y

# 启动 MySQL
sudo systemctl start mysql
sudo systemctl enable mysql

# 安全配置
sudo mysql_secure_installation

# 登录 MySQL
sudo mysql -u root -p

# 创建数据库和用户
CREATE DATABASE blog_db CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'blog_user'@'localhost' IDENTIFIED BY 'your_password';
GRANT ALL PRIVILEGES ON blog_db.* TO 'blog_user'@'localhost';
FLUSH PRIVILEGES;

2.1.3 安装 Redis

# 安装 Redis
sudo apt install redis-server -y

# 修改配置
sudo nano /etc/redis/redis.conf

# 设置密码（找到 requirepass 取消注释）
requirepass your_redis_password

# 重启 Redis
sudo systemctl restart redis
sudo systemctl enable redis

# 验证安装
redis-cli –version
redis-cli -a your_redis_password ping

2.1.4 安装 Node.js 和 npm

# 使用 nvm 安装（推荐）
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
source ~/.bashrc

# 安装 Node.js 18
nvm install 18
nvm use 18
nvm alias default 18

# 验证安装
node –version
npm –version

2.1.5 安装 Maven

# 安装 Maven
sudo apt install maven -y

# 验证安装
mvn –version

# 配置阿里云镜像（加速）
sudo nano /etc/maven/settings.xml

# 在 mirrors 标签内添加：
<mirror>
<id>aliyunmaven</id>
<mirrorOf>*</mirrorOf>
<name>阿里云公共仓库</name>
<url>https://maven.aliyun.com/repository/public</url>
</mirror>

2.1.6 安装 Git

# 安装 Git
sudo apt install git -y

# 配置 Git
git config –global user.name "Your Name"
git config –global user.email "your@email.com"

# 生成 SSH 密钥
ssh-keygen -t rsa -b 4096 -C "your@email.com"
cat ~/.ssh/id_rsa.pub
# 复制公钥添加到 GitHub/Gitee

2.2 Windows 环境搭建

2.2.1 安装 JDK 17

2.2.2 安装 MySQL 8.0

CREATE DATABASE blog_db CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'blog_user'@'localhost' IDENTIFIED BY 'your_password';
GRANT ALL PRIVILEGES ON blog_db.* TO 'blog_user'@'localhost';
FLUSH PRIVILEGES;

2.2.3 安装 Redis for Windows

requirepass your_redis_password

redis-server –service-install redis.windows.conf
redis-server –service-start

2.2.4 安装 Node.js

node –version
npm –version

2.2.5 安装 Maven

2.2.6 安装 Git

git config –global user.name "Your Name"
git config –global user.email "your@email.com"
ssh-keygen -t rsa -b 4096 -C "your@email.com"
cat ~/.ssh/id_rsa.pub

2.2.7 安装开发工具

# IntelliJ IDEA（推荐）
# 下载地址：https://www.jetbrains.com/idea/download/

# VS Code
# 下载地址：https://code.visualstudio.com/

# Navicat/DBeaver（数据库工具）
# DBeaver 免费版：https://dbeaver.io/download/

三、快速体验框架使用

3.1 框架官网示例

3.1.1 克隆示例项目

# 创建项目目录
mkdir -p ~/projects/blog
cd ~/projects/blog

# 克隆示例项目（以若依为例，可根据实际框架调整）
git clone https://gitee.com/y_project/RuoYi-Vue.git ruoyi-demo
cd ruoyi-demo

3.1.2 导入数据库

# 创建数据库
mysql -u root -p
CREATE DATABASE ry-vue CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
USE ry-vue;
source /path/to/ruoyi-demo/sql/ry_2024xxxx.sql;

3.1.3 修改配置文件

# 编辑配置文件
nano ruoyi-admin/src/main/resources/application-druid.yml

# 修改数据库连接
spring:
datasource:
url: jdbc:mysql://localhost:3306/ry-vue?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8
username: root
password: your_password

# 修改Redis配置
nano ruoyi-admin/src/main/resources/application.yml
redis:
host: localhost
port: 6379
password: your_redis_password

3.1.4 启动后端

# 编译打包
cd ruoyi-demo
mvn clean package

# 启动服务
cd ruoyi-admin/target
java -jar ruoyi-admin.jar

# 或使用 IDEA 启动
# 打开项目，运行 RuoYiApplication.java

3.1.5 启动前端

# 进入前端目录
cd ruoyi-ui

# 安装依赖（使用淘宝镜像）
npm install –registry=https://registry.npmmirror.com

# 启动开发服务器
npm run dev

# 访问 http://localhost:80
# 默认账号: admin 密码: admin123

3.2 快速理解框架结构

3.2.1 后端结构

ruoyi-demo/
├── ruoyi-admin # 启动模块
├── ruoyi-common # 通用工具类
├── ruoyi-framework # 框架核心
├── ruoyi-generator # 代码生成
├── ruoyi-quartz # 定时任务
├── ruoyi-system # 系统模块
└── ruoyi-ui # 前端模块

3.2.2 前端结构

ruoyi-ui/
├── src/
│ ├── api/ # API接口
│ ├── assets/ # 静态资源
│ ├── components/ # 通用组件
│ ├── layout/ # 布局组件
│ ├── router/ # 路由配置
│ ├── store/ # 状态管理
│ ├── utils/ # 工具类
│ └── views/ # 页面视图
├── public/ # 公共资源
└── package.json # 依赖配置

3.3 生成第一个CRUD

3.3.1 使用代码生成器

3.3.2 导入生成的代码

# 解压下载的代码
unzip ruoyi.zip -d generated-code

# 复制后端代码
cp -r generated-code/main/* src/main/

# 复制前端代码
cp -r generated-code/vue/* ruoyi-ui/src/

# 执行SQL
mysql -u root -p blog_db < generated-code/sql/xxx_menu.sql

3.3.3 测试生成的CRUD

四、数据库表构建

4.1 用户表设计

4.1.1 用户主表 (blog_user)

CREATE TABLE `blog_user` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '用户ID',
`username` varchar(50) NOT NULL COMMENT '用户名',
`password` varchar(100) NOT NULL COMMENT '密码',
`salt` varchar(50) DEFAULT NULL COMMENT '密码盐',
`email` varchar(100) DEFAULT NULL COMMENT '邮箱',
`phone` varchar(20) DEFAULT NULL COMMENT '手机号',
`avatar` varchar(500) DEFAULT NULL COMMENT '头像地址',
`nickname` varchar(50) DEFAULT NULL COMMENT '昵称',
`real_name` varchar(50) DEFAULT NULL COMMENT '真实姓名',
`gender` tinyint(1) DEFAULT '0' COMMENT '性别(0:未知 1:男 2:女)',
`birthday` date DEFAULT NULL COMMENT '生日',
`signature` varchar(500) DEFAULT NULL COMMENT '个性签名',
`status` tinyint(1) DEFAULT '1' COMMENT '状态(0:禁用 1:正常)',
`login_ip` varchar(50) DEFAULT NULL COMMENT '最后登录IP',
`login_time` datetime DEFAULT NULL COMMENT '最后登录时间',
`create_by` varchar(50) DEFAULT NULL COMMENT '创建者',
`create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`update_by` varchar(50) DEFAULT NULL COMMENT '更新者',
`update_time` datetime DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
`deleted` tinyint(1) DEFAULT '0' COMMENT '逻辑删除(0:正常 1:删除)',
PRIMARY KEY (`id`),
UNIQUE KEY `idx_username` (`username`),
UNIQUE KEY `idx_email` (`email`),
UNIQUE KEY `idx_phone` (`phone`),
KEY `idx_status` (`status`),
KEY `idx_create_time` (`create_time`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='博客用户表';

4.1.2 用户登录记录表 (blog_user_login_log)

CREATE TABLE `blog_user_login_log` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '日志ID',
`user_id` bigint(20) NOT NULL COMMENT '用户ID',
`username` varchar(50) NOT NULL COMMENT '用户名',
`login_type` tinyint(1) DEFAULT '1' COMMENT '登录类型(1:密码登录 2:验证码登录)',
`ip` varchar(50) DEFAULT NULL COMMENT '登录IP',
`location` varchar(100) DEFAULT NULL COMMENT '登录地点',
`device` varchar(100) DEFAULT NULL COMMENT '登录设备',
`browser` varchar(50) DEFAULT NULL COMMENT '浏览器',
`os` varchar(50) DEFAULT NULL COMMENT '操作系统',
`status` tinyint(1) DEFAULT '1' COMMENT '状态(1:成功 0:失败)',
`message` varchar(255) DEFAULT NULL COMMENT '消息',
`create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
PRIMARY KEY (`id`),
KEY `idx_user_id` (`user_id`),
KEY `idx_create_time` (`create_time`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户登录日志表';

4.1.3 验证码记录表 (blog_captcha)

CREATE TABLE `blog_captcha` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'ID',
`uuid` varchar(100) NOT NULL COMMENT '唯一标识',
`code` varchar(10) NOT NULL COMMENT '验证码',
`type` tinyint(1) DEFAULT '1' COMMENT '类型(1:图形验证码 2:短信验证码 3:邮箱验证码)',
`target` varchar(100) DEFAULT NULL COMMENT '目标(手机号/邮箱)',
`expire_time` datetime NOT NULL COMMENT '过期时间',
`status` tinyint(1) DEFAULT '1' COMMENT '状态(1:未使用 0:已使用)',
`create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
PRIMARY KEY (`id`),
KEY `idx_uuid` (`uuid`),
KEY `idx_target` (`target`),
KEY `idx_expire_time` (`expire_time`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='验证码记录表';

4.1.4 用户配置表 (blog_user_config)

CREATE TABLE `blog_user_config` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'ID',
`user_id` bigint(20) NOT NULL COMMENT '用户ID',
`theme` varchar(50) DEFAULT 'default' COMMENT '主题(default:默认 dark:暗黑 mourning:追悼)',
`font_size` tinyint(2) DEFAULT '14' COMMENT '字体大小',
`font_family` varchar(50) DEFAULT 'Microsoft YaHei' COMMENT '字体',
`language` varchar(10) DEFAULT 'zh-CN' COMMENT '语言',
`notification` tinyint(1) DEFAULT '1' COMMENT '通知(1:开启 0:关闭)',
`privacy` tinyint(1) DEFAULT '0' COMMENT '隐私模式(0:公开 1:私密)',
`create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`update_time` datetime DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `idx_user_id` (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户配置表';

4.1.5 用户角色表 (blog_role)

CREATE TABLE `blog_role` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '角色ID',
`role_code` varchar(50) NOT NULL COMMENT '角色编码',
`role_name` varchar(50) NOT NULL COMMENT '角色名称',
`description` varchar(255) DEFAULT NULL COMMENT '描述',
`sort` int(5) DEFAULT '0' COMMENT '排序',
`status` tinyint(1) DEFAULT '1' COMMENT '状态(0:禁用 1:正常)',
`create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`update_time` datetime DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `idx_role_code` (`role_code`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='角色表';

— 初始化角色数据
INSERT INTO `blog_role` (`role_code`, `role_name`, `description`, `sort`) VALUES
('admin', '管理员', '系统管理员', 1),
('editor', '编辑', '内容编辑', 2),
('user', '普通用户', '普通注册用户', 3),
('vip', 'VIP用户', '付费用户', 4);

4.1.6 用户角色关联表 (blog_user_role)

CREATE TABLE `blog_user_role` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'ID',
`user_id` bigint(20) NOT NULL COMMENT '用户ID',
`role_id` bigint(20) NOT NULL COMMENT '角色ID',
`create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
PRIMARY KEY (`id`),
UNIQUE KEY `idx_user_role` (`user_id`, `role_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户角色关联表';

4.2 数据库构建方式

4.2.1 方式一：手动执行SQL脚本

# 创建数据库
mysql -u root -p -e "CREATE DATABASE IF NOT EXISTS blog_db CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;"

# 导入SQL文件
mysql -u root -p blog_db < ~/projects/blog/sql/blog_schema.sql
mysql -u root -p blog_db < ~/projects/blog/sql/blog_data.sql

4.2.2 方式二：使用Flyway自动迁移

<!– pom.xml 添加依赖 –>
<dependency>
<groupId>org.flywaydb</groupId>
<artifactId>flyway-core</artifactId>
<version>9.16.0</version>
</dependency>
<dependency>
<groupId>org.flywaydb</groupId>
<artifactId>flyway-mysql</artifactId>
<version>9.16.0</version>
</dependency>

# application.yml 配置
spring:
flyway:
enabled: true
baseline-on-migrate: true
locations: classpath:db/migration
table: flyway_schema_history

创建迁移文件：

# 创建目录
mkdir -p src/main/resources/db/migration

# 创建初始版本 V1__init_schema.sql
nano src/main/resources/db/migration/V1__init_schema.sql

— V1__init_schema.sql
— 用户表
CREATE TABLE IF NOT EXISTS `blog_user` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '用户ID',
`username` varchar(50) NOT NULL COMMENT '用户名',
— … 其他字段
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='博客用户表';

— 创建索引
CREATE INDEX idx_username ON blog_user(username);
CREATE INDEX idx_email ON blog_user(email);

# 创建V2__init_data.sql
nano src/main/resources/db/migration/V2__init_data.sql

— V2__init_data.sql
— 初始化角色数据
INSERT INTO `blog_role` (`role_code`, `role_name`, `description`) VALUES
('admin', '管理员', '系统管理员'),
('user', '普通用户', '普通注册用户');

— 初始化管理员账号（密码: admin123）
INSERT INTO `blog_user` (`username`, `password`, `salt`, `email`, `status`) VALUES
('admin', '加密后的密码', '随机salt', 'admin@blog.com', 1);

4.2.3 使用MyBatis-Plus代码生成器

// CodeGenerator.java
package com.blog.generator;

import com.baomidou.mybatisplus.generator.FastAutoGenerator;
import com.baomidou.mybatisplus.generator.config.OutputFile;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;

import java.util.Collections;

public class CodeGenerator {
public static void main(String[] args) {
String projectPath = System.getProperty("user.dir");

FastAutoGenerator.create("jdbc:mysql://localhost:3306/blog_db?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8",
"root", "your_password")
.globalConfig(builder -> {
builder.author("Your Name") // 作者
.outputDir(projectPath + "/src/main/java") // 输出路径
.dateType(DateType.ONLY_DATE) // 日期类型
.commentDate("yyyy-MM-dd") // 注释日期
.disableOpenDir(); // 禁止打开输出目录
})
.packageConfig(builder -> {
builder.parent("com.blog") // 父包名
.moduleName("modules") // 模块名
.entity("entity") // 实体类包名
.service("service") // service包名
.serviceImpl("service.impl") // serviceImpl包名
.mapper("mapper") // mapper包名
.controller("controller") // controller包名
.xml("mapper.xml") // mapper.xml包名
.pathInfo(Collections.singletonMap(OutputFile.xml, projectPath + "/src/main/resources/mapper")); // mapper.xml路径
})
.strategyConfig(builder -> {
builder.addInclude("blog_user", "blog_role", "blog_user_role") // 表名
.addTablePrefix("blog_") // 表前缀
.entityBuilder()
.enableLombok() // 启用Lombok
.enableChainModel() // 链式模型
.enableTableFieldAnnotation() // 启用字段注解
.controllerBuilder()
.enableRestStyle() // Rest风格
.enableHyphenStyle() // 连字符风格
.mapperBuilder()
.enableBaseResultMap() // 启用BaseResultMap
.enableBaseColumnList(); // 启用BaseColumnList
})
.templateEngine(new FreemarkerTemplateEngine()) // 模板引擎
.execute();
}
}

五、后端API接口实现与测试

5.1 项目结构

blog-backend/
├── src/main/java/com/blog/
│ ├── BlogApplication.java # 启动类
│ ├── common/ # 公共模块
│ │ ├── constant/ # 常量定义
│ │ ├── exception/ # 异常处理
│ │ ├── result/ # 统一返回结果
│ │ ├── util/ # 工具类
│ │ └── validator/ # 验证器
│ ├── config/ # 配置类
│ │ ├── SecurityConfig.java # 安全配置
│ │ ├── RedisConfig.java # Redis配置
│ │ ├── SwaggerConfig.java # API文档配置
│ │ └── WebConfig.java # Web配置
│ ├── modules/ # 功能模块
│ │ └── auth/ # 认证模块
│ │ ├── controller/ # 控制器
│ │ ├── service/ # 服务层
│ │ ├── mapper/ # 数据访问
│ │ ├── entity/ # 实体类
│ │ ├── dto/ # 数据传输对象
│ │ └── vo/ # 视图对象
│ └── security/ # 安全相关
│ ├── filter/ # 过滤器
│ ├── handler/ # 处理器
│ └── utils/ # 安全工具类
└── src/main/resources/
├── application.yml # 主配置文件
├── application-dev.yml # 开发环境配置
└── mapper/ # MyBatis XML文件

5.2 依赖配置

<!– pom.xml –>
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.14</version>
</parent>

<groupId>com.blog</groupId>
<artifactId>blog-backend</artifactId>
<version>1.0.0</version>
<packaging>jar</packaging>

<properties>
<java.version>17</java.version>
<mybatis-plus.version>3.5.3</mybatis-plus.version>
<jwt.version>0.11.5</jwt.version>
<fastjson.version>2.0.32</fastjson.version>
</properties>

<dependencies>
<!– Spring Boot Starters –>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-mail</artifactId>
</dependency>

<!– Database –>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>${mybatis-plus.version}</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.33</version>
</dependency>

<!– JWT –>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-api</artifactId>
<version>${jwt.version}</version>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-impl</artifactId>
<version>${jwt.version}</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt-jackson</artifactId>
<version>${jwt.version}</version>
<scope>runtime</scope>
</dependency>

<!– Tools –>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>${fastjson.version}</version>
</dependency>
<dependency>
<groupId>cn.hutool</groupId>
<artifactId>hutool-all</artifactId>
<version>5.8.20</version>
</dependency>
<dependency>
<groupId>com.github.whvcse</groupId>
<artifactId>easy-captcha</artifactId>
<version>1.6.2</version>
</dependency>

<!– API文档 –>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-boot-starter</artifactId>
<version>3.0.0</version>
</dependency>

<!– Test –>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<excludes>
<exclude>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</exclude>
</excludes>
</configuration>
</plugin>
</plugins>
</build>
</project>

5.3 配置文件

# application.yml
spring:
profiles:
active: dev
application:
name: blog–backend

—
# application-dev.yml
spring:
datasource:
url: jdbc:mysql://localhost:3306/blog_db?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false
username: root
password: your_password
driver-class-name: com.mysql.cj.jdbc.Driver
hikari:
minimum-idle: 5
maximum-pool-size: 20
idle-timeout: 30000
connection-timeout: 30000

redis:
host: localhost
port: 6379
password: your_redis_password
database: 0
timeout: 5000ms
lettuce:
pool:
max-active: 8
max-idle: 8
min-idle: 0

mail:
host: smtp.163.com
port: 465
username: your_email@163.com
password: your_authorization_code
protocol: smtp
properties:
mail.smtp.auth: true
mail.smtp.ssl.enable: true
mail.smtp.starttls.enable: true

servlet:
multipart:
max-file-size: 10MB
max-request-size: 100MB

mybatis-plus:
mapper-locations: classpath*:/mapper/**/*.xml
type-aliases-package: com.blog.modules.*.entity
global-config:
db-config:
id-type: auto
logic-delete-field: deleted
logic-delete-value: 1
logic-not-delete-value: 0
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
map-underscore-to-camel-case: true

jwt:
secret: your_jwt_secret_key_here_minimum_32_bytes_long
expiration: 86400000 # 24小时
refresh-expiration: 604800000 # 7天
header: Authorization
token-prefix: Bearer

blog:
site:
title: 我的技术博客
icp: 京ICP备xxxxxx号
font:
path: /usr/share/fonts/blog/
default: Microsoft YaHei.ttf
captcha:
width: 120
height: 40
length: 4
expire: 300 # 5分钟

5.4 统一返回结果

// common/result/Result.java
package com.blog.common.result;

import lombok.Data;
import java.io.Serializable;

@Data
public class Result<T> implements Serializable {
private static final long serialVersionUID = 1L;

private int code;
private String msg;
private T data;
private long timestamp;

private Result() {
this.timestamp = System.currentTimeMillis();
}

public static <T> Result<T> success() {
Result<T> result = new Result<>();
result.setCode(200);
result.setMsg("操作成功");
return result;
}

public static <T> Result<T> success(T data) {
Result<T> result = new Result<>();
result.setCode(200);
result.setMsg("操作成功");
result.setData(data);
return result;
}

public static <T> Result<T> success(String msg, T data) {
Result<T> result = new Result<>();
result.setCode(200);
result.setMsg(msg);
result.setData(data);
return result;
}

public static <T> Result<T> error() {
Result<T> result = new Result<>();
result.setCode(500);
result.setMsg("操作失败");
return result;
}

public static <T> Result<T> error(String msg) {
Result<T> result = new Result<>();
result.setCode(500);
result.setMsg(msg);
return result;
}

public static <T> Result<T> error(int code, String msg) {
Result<T> result = new Result<>();
result.setCode(code);
result.setMsg(msg);
return result;
}

public static <T> Result<T> unauthorized() {
Result<T> result = new Result<>();
result.setCode(401);
result.setMsg("未授权");
return result;
}

public static <T> Result<T> forbidden() {
Result<T> result = new Result<>();
result.setCode(403);
result.setMsg("禁止访问");
return result;
}

public boolean isSuccess() {
return this.code == 200;
}
}

// common/result/ResultCode.java
package com.blog.common.result;

public interface ResultCode {
int SUCCESS = 200;
int FAIL = 500;
int UNAUTHORIZED = 401;
int FORBIDDEN = 403;
int NOT_FOUND = 404;
int VALIDATE_FAILED = 400;

String SUCCESS_MSG = "操作成功";
String FAIL_MSG = "操作失败";
String UNAUTHORIZED_MSG = "未授权，请先登录";
String FORBIDDEN_MSG = "没有权限访问";
String NOT_FOUND_MSG = "资源不存在";
String VALIDATE_FAILED_MSG = "参数校验失败";
}

5.5 实体类

// modules/auth/entity/User.java
package com.blog.modules.auth.entity;

import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.experimental.Accessors;
import java.time.LocalDateTime;

@Data
@Accessors(chain = true)
@TableName("blog_user")
public class User {

@TableId(type = IdType.AUTO)
private Long id;

private String username;

private String password;

private String salt;

private String email;

private String phone;

private String avatar;

private String nickname;

private String realName;

private Integer gender;

private LocalDate birthday;

private String signature;

private Integer status;

private String loginIp;

private LocalDateTime loginTime;

private String createBy;

@TableField(fill = FieldFill.INSERT)
private LocalDateTime createTime;

private String updateBy;

@TableField(fill = FieldFill.UPDATE)
private LocalDateTime updateTime;

@TableLogic
private Integer deleted;

// 非数据库字段
@TableField(exist = false)
private List<Role> roles;

@TableField(exist = false)
private String token;
}

// modules/auth/dto/LoginRequest.java
package com.blog.modules.auth.dto;

import lombok.Data;
import javax.validation.constraints.NotBlank;

@Data
public class LoginRequest {

@NotBlank(message = "账号不能为空")
private String account; // 可以是用户名/邮箱/手机号

@NotBlank(message = "密码不能为空")
private String password;

private String captcha;

private String captchaKey;

private Boolean rememberMe;
}

// modules/auth/dto/RegisterRequest.java
package com.blog.modules.auth.dto;

import lombok.Data;
import javax.validation.constraints.*;

@Data
public class RegisterRequest {

@NotBlank(message = "用户名不能为空")
@Pattern(regexp = "^[a-zA-Z0-9_]{4,20}$", message = "用户名必须是4-20位字母、数字或下划线")
private String username;

@NotBlank(message = "密码不能为空")
@Pattern(regexp = "^(?=.*[0-9])(?=.*[a-zA-Z])(?=.*[@#$%^&+=])(?=\\\\S+$).{8,20}$",
message = "密码必须包含字母、数字和特殊字符，长度8-20位")
private String password;

@NotBlank(message = "确认密码不能为空")
private String confirmPassword;

@Email(message = "邮箱格式不正确")
private String email;

@Pattern(regexp = "^1[3-9]\\\\d{9}$", message = "手机号格式不正确")
private String phone;

@NotBlank(message = "验证码不能为空")
private String captcha;

@NotBlank(message = "验证码Key不能为空")
private String captchaKey;

@AssertTrue(message = "必须同意用户协议")
private Boolean agreement;
}

5.6 工具类

// security/utils/JwtUtil.java
package com.blog.security.utils;

import io.jsonwebtoken.*;
import io.jsonwebtoken.security.Keys;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.security.Key;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;

@Slf4j
@Component
public class JwtUtil {

@Value("${jwt.secret}")
private String secret;

@Value("${jwt.expiration}")
private Long expiration;

@Value("${jwt.refresh-expiration}")
private Long refreshExpiration;

private Key getSigningKey() {
return Keys.hmacShaKeyFor(secret.getBytes());
}

public String generateToken(String username) {
Map<String, Object> claims = new HashMap<>();
return createToken(claims, username, expiration);
}

public String generateRefreshToken(String username) {
Map<String, Object> claims = new HashMap<>();
return createToken(claims, username, refreshExpiration);
}

private String createToken(Map<String, Object> claims, String subject, Long expiration) {
return Jwts.builder()
.setClaims(claims)
.setSubject(subject)
.setIssuedAt(new Date(System.currentTimeMillis()))
.setExpiration(new Date(System.currentTimeMillis() + expiration))
.signWith(getSigningKey(), SignatureAlgorithm.HS256)
.compact();
}

public String extractUsername(String token) {
return extractClaim(token, Claims::getSubject);
}

public Date extractExpiration(String token) {
return extractClaim(token, Claims::getExpiration);
}

public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
final Claims claims = extractAllClaims(token);
return claimsResolver.apply(claims);
}

private Claims extractAllClaims(String token) {
try {
return Jwts.parserBuilder()
.setSigningKey(getSigningKey())
.build()
.parseClaimsJws(token)
.getBody();
} catch (ExpiredJwtException e) {
log.error("Token已过期: {}", e.getMessage());
throw e;
} catch (JwtException e) {
log.error("Token解析失败: {}", e.getMessage());
throw e;
}
}

private Boolean isTokenExpired(String token) {
try {
Date expiration = extractExpiration(token);
return expiration.before(new Date());
} catch (ExpiredJwtException e) {
return true;
}
}

public Boolean validateToken(String token, String username) {
try {
String extractedUsername = extractUsername(token);
return (extractedUsername.equals(username) && !isTokenExpired(token));
} catch (Exception e) {
log.error("Token验证失败: {}", e.getMessage());
return false;
}
}

public Boolean validateToken(String token) {
try {
return !isTokenExpired(token);
} catch (Exception e) {
return false;
}
}

public Long getRemainingTime(String token) {
Date expiration = extractExpiration(token);
long remaining = expiration.getTime() – System.currentTimeMillis();
return remaining > 0 ? remaining : 0;
}
}

// common/util/CaptchaUtil.java
package com.blog.common.util;

import com.wf.captcha.ArithmeticCaptcha;
import com.wf.captcha.GifCaptcha;
import com.wf.captcha.SpecCaptcha;
import com.wf.captcha.base.Captcha;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

@Slf4j
@Component
public class CaptchaUtil {

@Value("${blog.captcha.width:120}")
private int width;

@Value("${blog.captcha.height:40}")
private int height;

@Value("${blog.captcha.length:4}")
private int length;

@Value("${blog.captcha.expire:300}")
private int expire;

private final StringRedisTemplate redisTemplate;

public CaptchaUtil(StringRedisTemplate redisTemplate) {
this.redisTemplate = redisTemplate;
}

/**
* 生成图形验证码（标准类型）
*/
public CaptchaInfo generateSpecCaptcha() {
SpecCaptcha captcha = new SpecCaptcha(width, height, length);
return saveCaptcha(captcha);
}

/**
* 生成图形验证码（GIF类型）
*/
public CaptchaInfo generateGifCaptcha() {
GifCaptcha captcha = new GifCaptcha(width, height, length);
return saveCaptcha(captcha);
}

/**
* 生成算术验证码
*/
public CaptchaInfo generateArithmeticCaptcha() {
ArithmeticCaptcha captcha = new ArithmeticCaptcha(width, height);
captcha.setLen(2); // 运算位数
return saveCaptcha(captcha);
}

/**
* 保存验证码到Redis
*/
private CaptchaInfo saveCaptcha(Captcha captcha) {
String key = UUID.randomUUID().toString().replace("-", "");
String code = captcha.text();

// 统一转为大写存储，实现忽略大小写验证
code = code.toUpperCase();

// 存储到Redis
redisTemplate.opsForValue().set(
"captcha:" + key,
code,
expire,
TimeUnit.SECONDS
);

CaptchaInfo info = new CaptchaInfo();
info.setKey(key);
info.setImage(captcha.toBase64());
info.setExpire(expire);

log.debug("验证码生成成功, key: {}, code: {}", key, code);
return info;
}

/**
* 验证验证码（忽略大小写）
*/
public boolean validate(String key, String code) {
if (key == null || code == null) {
return false;
}

String cacheCode = redisTemplate.opsForValue().get("captcha:" + key);
if (cacheCode == null) {
log.debug("验证码已过期或不存在, key: {}", key);
return false;
}

// 删除已使用的验证码
redisTemplate.delete("captcha:" + key);

// 忽略大小写验证
boolean result = cacheCode.equalsIgnoreCase(code);
log.debug("验证码验证, key: {}, input: {}, cache: {}, result: {}",
key, code, cacheCode, result);

return result;
}

/**
* 验证码信息类
*/
@Data
public static class CaptchaInfo {
private String key;
private String image;
private int expire;
}
}

// common/util/PasswordEncoder.java
package com.blog.common.util;

import cn.hutool.crypto.SecureUtil;
import cn.hutool.crypto.digest.BCrypt;
import org.springframework.stereotype.Component;
import java.util.UUID;

@Component
public class PasswordEncoder {

/**
* 生成BCrypt加密密码
*/
public String encode(String rawPassword) {
return BCrypt.hashpw(rawPassword, BCrypt.gensalt());
}

/**
* 验证BCrypt密码
*/
public boolean matches(String rawPassword, String encodedPassword) {
if (encodedPassword == null || encodedPassword.isEmpty()) {
return false;
}
return BCrypt.checkpw(rawPassword, encodedPassword);
}

/**
* 生成MD5加密密码（带盐）
*/
public String encodeMd5(String rawPassword, String salt) {
return SecureUtil.md5(rawPassword + salt);
}

/**
* 生成随机盐
*/
public String generateSalt() {
return UUID.randomUUID().toString().replace("-", "").substring(0, 16);
}

/**
* 验证MD5密码
*/
public boolean matchesMd5(String rawPassword, String salt, String encodedPassword) {
String newEncoded = encodeMd5(rawPassword, salt);
return newEncoded.equals(encodedPassword);
}
}

5.7 Service层实现

// modules/auth/service/UserService.java
package com.blog.modules.auth.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.blog.modules.auth.dto.LoginRequest;
import com.blog.modules.auth.dto.RegisterRequest;
import com.blog.modules.auth.entity.User;
import com.blog.modules.auth.vo.LoginVO;

public interface UserService extends IService<User> {

/**
* 用户注册
*/
User register(RegisterRequest request);

/**
* 用户登录
*/
LoginVO login(LoginRequest request);

/**
* 刷新Token
*/
String refreshToken(String refreshToken);

/**
* 退出登录
*/
void logout(String token);

/**
* 根据用户名查询用户
*/
User getByUsername(String username);

/**
* 根据邮箱查询用户
*/
User getByEmail(String email);

/**
* 根据手机号查询用户
*/
User getByPhone(String phone);

/**
* 检查用户名是否存在
*/
boolean checkUsernameExists(String username);

/**
* 检查邮箱是否存在
*/
boolean checkEmailExists(String email);

/**
* 检查手机号是否存在
*/
boolean checkPhoneExists(String phone);

/**
* 更新最后登录信息
*/
void updateLoginInfo(Long userId, String ip);

/**
* 修改密码
*/
boolean changePassword(Long userId, String oldPassword, String newPassword);

/**
* 重置密码
*/
boolean resetPassword(String email, String newPassword);
}

// modules/auth/service/impl/UserServiceImpl.java
package com.blog.modules.auth.service.impl;

import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.blog.common.exception.BusinessException;
import com.blog.common.util.CaptchaUtil;
import com.blog.common.util.PasswordEncoder;
import com.blog.modules.auth.dto.LoginRequest;
import com.blog.modules.auth.dto.RegisterRequest;
import com.blog.modules.auth.entity.User;
import com.blog.modules.auth.entity.UserLoginLog;
import com.blog.modules.auth.mapper.UserMapper;
import com.blog.modules.auth.service.UserLoginLogService;
import com.blog.modules.auth.service.UserService;
import com.blog.modules.auth.vo.LoginVO;
import com.blog.security.utils.JwtUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;
import java.util.concurrent.TimeUnit;

@Slf4j
@Service
@RequiredArgsConstructor
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

private final PasswordEncoder passwordEncoder;
private final JwtUtil jwtUtil;
private final CaptchaUtil captchaUtil;
private final StringRedisTemplate redisTemplate;
private final UserLoginLogService loginLogService;
private final HttpServletRequest request;

@Override
@Transactional(rollbackFor = Exception.class)
public User register(RegisterRequest req) {
log.info("用户注册: {}", req.getUsername());

// 验证码校验
if (!captchaUtil.validate(req.getCaptchaKey(), req.getCaptcha())) {
throw new BusinessException("验证码错误");
}

// 密码一致性校验
if (!req.getPassword().equals(req.getConfirmPassword())) {
throw new BusinessException("两次输入的密码不一致");
}

// 检查用户名是否存在
if (checkUsernameExists(req.getUsername())) {
throw new BusinessException("用户名已存在");
}

// 检查邮箱是否存在
if (StrUtil.isNotBlank(req.getEmail()) && checkEmailExists(req.getEmail())) {
throw new BusinessException("邮箱已被注册");
}

// 检查手机号是否存在
if (StrUtil.isNotBlank(req.getPhone()) && checkPhoneExists(req.getPhone())) {
throw new BusinessException("手机号已被注册");
}

// 创建新用户
User user = new User();
user.setUsername(req.getUsername());
user.setPassword(passwordEncoder.encode(req.getPassword()));
user.setEmail(req.getEmail());
user.setPhone(req.getPhone());
user.setNickname(req.getUsername());
user.setStatus(1); // 正常状态
user.setCreateTime(LocalDateTime.now());

// 保存用户
save(user);

// 分配默认角色（普通用户）
// userRoleService.assignDefaultRole(user.getId());

log.info("用户注册成功: {}, id: {}", req.getUsername(), user.getId());
return user;
}

@Override
public LoginVO login(LoginRequest req) {
log.info("用户登录: {}", req.getAccount());

// 登录失败次数检查
String loginFailKey = "login:fail:" + req.getAccount();
String failCountStr = redisTemplate.opsForValue().get(loginFailKey);
int failCount = failCountStr == null ? 0 : Integer.parseInt(failCountStr);

// 失败超过3次需要验证码
if (failCount >= 3) {
if (StrUtil.isBlank(req.getCaptcha()) || StrUtil.isBlank(req.getCaptchaKey())) {
throw new BusinessException("请输入验证码");
}
if (!captchaUtil.validate(req.getCaptchaKey(), req.getCaptcha())) {
throw new BusinessException("验证码错误");
}
}

// 查询用户
User user = null;
if (req.getAccount().contains("@")) {
user = getByEmail(req.getAccount());
} else if (req.getAccount().matches("^1[3-9]\\\\d{9}$")) {
user = getByPhone(req.getAccount());
} else {
user = getByUsername(req.getAccount());
}

// 用户不存在或密码错误
if (user == null || !passwordEncoder.matches(req.getPassword(), user.getPassword())) {
// 记录失败次数
redisTemplate.opsForValue().set(loginFailKey, String.valueOf(failCount + 1), 30, TimeUnit.MINUTES);
throw new BusinessException("用户名或密码错误");
}

// 检查用户状态
if (user.getStatus() != 1) {
throw new BusinessException("账号已被禁用");
}

// 登录成功，清除失败记录
redisTemplate.delete(loginFailKey);

// 生成Token
String token = jwtUtil.generateToken(user.getUsername());
String refreshToken = jwtUtil.generateRefreshToken(user.getUsername());

// 更新登录信息
String ip = getClientIp();
updateLoginInfo(user.getId(), ip);

// 记录登录日志
UserLoginLog loginLog = new UserLoginLog();
loginLog.setUserId(user.getId());
loginLog.setUsername(user.getUsername());
loginLog.setIp(ip);
loginLog.setStatus(1);
loginLog.setCreateTime(LocalDateTime.now());
loginLogService.save(loginLog);

// 返回登录信息
LoginVO vo = new LoginVO();
vo.setToken(token);
vo.setRefreshToken(refreshToken);
vo.setExpiresIn(jwtUtil.getRemainingTime(token));
vo.setUser(user);

log.info("用户登录成功: {}, id: {}", req.getAccount(), user.getId());
return vo;
}

@Override
public String refreshToken(String refreshToken) {
if (!jwtUtil.validateToken(refreshToken)) {
throw new BusinessException("刷新Token无效或已过期");
}

String username = jwtUtil.extractUsername(refreshToken);
User user = getByUsername(username);

if (user == null || user.getStatus() != 1) {
throw new BusinessException("用户不存在或已被禁用");
}

return jwtUtil.generateToken(username);
}

@Override
public void logout(String token) {
// 将Token加入黑名单
if (StrUtil.isNotBlank(token)) {
long remaining = jwtUtil.getRemainingTime(token);
if (remaining > 0) {
redisTemplate.opsForValue().set("blacklist:token:" + token, "1", remaining, TimeUnit.MILLISECONDS);
}
}
log.info("用户退出登录");
}

@Override
public User getByUsername(String username) {
return getOne(new LambdaQueryWrapper<User>()
.eq(User::getUsername, username)
.eq(User::getDeleted, 0));
}

@Override
public User getByEmail(String email) {
return getOne(new LambdaQueryWrapper<User>()
.eq(User::getEmail, email)
.eq(User::getDeleted, 0));
}