Tio Boot DocsTio Boot Docs
Home
  • java-db
  • api-table
  • Enjoy
  • Tio Boot Admin
  • ai_agent
  • translator
  • knowlege_base
  • ai-search
  • 案例
Abount
  • Github
  • Gitee
Home
  • java-db
  • api-table
  • Enjoy
  • Tio Boot Admin
  • ai_agent
  • translator
  • knowlege_base
  • ai-search
  • 案例
Abount
  • Github
  • Gitee
  • 01_tio-boot 简介

    • tio-boot:新一代高性能 Java Web 开发框架
    • tio-boot 入门示例
    • Tio-Boot 配置 : 现代化的配置方案
    • tio-boot 整合 Logback
    • tio-boot 整合 hotswap-classloader 实现热加载
    • 自行编译 tio-boot
    • 最新版本
    • 开发规范
  • 02_部署

    • 使用 Maven Profile 实现分环境打包 tio-boot 项目
    • Maven 项目配置详解:依赖与 Profiles 配置
    • tio-boot 打包成 FatJar
    • 使用 GraalVM 构建 tio-boot Native 程序
    • 使用 Docker 部署 tio-boot
    • 部署到 Fly.io
    • 部署到 AWS Lambda
    • 到阿里云云函数
    • 使用 Deploy 工具部署
    • 使用Systemctl启动项目
    • 使用 Jenkins 部署 Tio-Boot 项目
    • 使用 Nginx 反向代理 Tio-Boot
    • 使用 Supervisor 管理 Java 应用
    • 已过时
    • 胖包与瘦包的打包与部署
  • 03_配置

    • 配置参数
    • 服务器监听器
    • 内置缓存系统 AbsCache
    • 使用 Redis 作为内部 Cache
    • 静态文件处理器
    • 基于域名的静态资源隔离
    • DecodeExceptionHandler
  • 04_原理

    • 生命周期
    • 请求处理流程
    • 重要的类
  • 05_json

    • Json
    • 接受 JSON 和响应 JSON
    • 响应实体类
  • 06_web

    • 概述
    • 文件上传
    • 接收请求参数
    • 接收日期参数
    • 接收数组参数
    • 返回字符串
    • 返回文本数据
    • 返回网页
    • 请求和响应字节
    • 文件下载
    • 返回视频文件并支持断点续传
    • http Session
    • Cookie
    • HttpRequest
    • HttpResponse
    • Resps
    • RespBodyVo
    • 请求拦截器
    • Controller拦截器
    • LoggingInterceptor
    • 全局异常处理器
    • 异步处理
    • 动态 返回 CSS 实现
    • 返回图片
    • Transfer-Encoding: chunked 实时音频播放
    • Server-Sent Events (SSE)
    • 接口访问统计
    • 接口请求和响应数据记录
    • 自定义 Handler 转发请求
    • 使用 HttpForwardHandler 转发所有请求
    • 跨域
    • 添加 Controller
    • 常用工具类
    • HTTP Basic 认证
    • Http响应加密
    • 在 Tio-boot 中使用零拷贝发送大文件
    • Tio Boot 分片上传服务设计与实现
    • WebJars
    • JProtobuf
    • Tio-Boot HTTP Speed Test
  • 07_validate

    • 数据紧校验规范
    • 参数校验
  • 08_websocket

    • 使用 tio-boot 搭建 WebSocket 服务
    • WebSocket 聊天室项目示例
  • 09_java-db

    • java‑db
    • 操作数据库入门示例
    • SQL 模板 (SqlTemplates)
    • 数据源配置与使用
    • ActiveRecord
    • Db 工具类
    • 批量操作
    • Model
    • 生成器与 Model
    • 注解
    • 异常处理
    • 数据库事务处理
    • Cache 缓存
    • Dialect 多数据库支持
    • 表关联操作
    • 复合主键
    • Oracle 支持
    • Enjoy SQL 模板
    • 整合 Enjoy 模板最佳实践
    • 多数据源支持
    • 独立使用 ActiveRecord
    • 调用存储过程
    • java-db 整合 Guava 的 Striped 锁优化
    • 生成 SQL
    • 通过实体类操作数据库
    • java-db 读写分离
    • Spring Boot 整合 Java-DB
    • like 查询
    • 常用操作示例
    • Druid 监控集成指南
    • SQL 统计
  • 10_api-table

    • ApiTable 概述
    • 使用 ApiTable 连接 SQLite
    • 使用 ApiTable 连接 Mysql
    • 使用 ApiTable 连接 Postgres
    • 使用 ApiTable 连接 TDEngine
    • 使用 api-table 连接 oracle
    • 使用 api-table 连接 mysql and tdengine 多数据源
    • EasyExcel 导出
    • EasyExcel 导入
    • TQL(Table SQL)前端输入规范
    • ApiTable 实现增删改查
    • 数组类型
    • 单独使用 ApiTable
  • 11_aop

    • JFinal-aop
    • Aop 工具类
    • 配置
    • 配置
    • 独立使用 JFinal Aop
    • @AImport
    • 原理解析
  • 12_cache

    • Caffine
    • Jedis-redis
    • hutool RedisDS
    • Redisson
    • Caffeine and redis
    • CacheUtils 工具类
    • 使用 CacheUtils 整合 caffeine 和 redis 实现的两级缓存
    • 使用 java-db 整合 ehcache
    • 使用 java-db 整合 redis
    • Java DB Redis 相关 Api
    • redis 使用示例
  • 13_认证和权限

    • FixedTokenInterceptor
    • TokenManager
    • 数据表
    • 匿名登录
    • 注册和登录
    • 个人中心
    • 重置密码
    • Google 登录
    • 短信登录
    • 移动端微信登录
    • 移动端重置密码
    • 微信登录
    • 移动端微信登录
    • 权限校验注解
    • Sa-Token
    • sa-token 登录注册
    • StpUtil.isLogin() 源码解析
  • 14_i18n

    • i18n
  • 15_enjoy

    • tio-boot 整合 Enjoy 模版引擎文档
    • Tio-Boot 整合 Java-DB 与 Enjoy 模板引擎示例
    • 引擎配置
    • 表达式
    • 指令
    • 注释
    • 原样输出
    • Shared Method 扩展
    • Shared Object 扩展
    • Extension Method 扩展
    • Spring boot 整合
    • 独立使用 Enjoy
    • tio-boot enjoy 自定义指令 localeDate
    • PromptEngine
    • Enjoy 入门示例-擎渲染大模型请求体
    • Enjoy 使用示例
  • 16_定时任务

    • Quartz 定时任务集成指南
    • 分布式定时任务 xxl-jb
    • cron4j 使用指南
  • 17_tests

    • TioBootTest 类
  • 18_tio

    • TioBootServer
    • 使用 tio-core 在 tio-boot 中构建独立的 TCP 服务器
    • 内置 TCP 处理器
    • 独立启动 UDPServer
    • 使用内置 UDPServer
    • t-io 消息处理流程
    • tio-运行原理详解
    • TioConfig
    • ChannelContext
    • Tio 工具类
    • 业务数据绑定
    • 业务数据解绑
    • 发送数据
    • 关闭连接
    • Packet
    • 监控: 心跳
    • 监控: 客户端的流量数据
    • 监控: 单条 TCP 连接的流量数据
    • 监控: 端口的流量数据
    • 单条通道统计: ChannelStat
    • 所有通道统计: GroupStat
    • 资源共享
    • 成员排序
    • SSL
    • DecodeRunnable
    • 使用 AsynchronousSocketChannel 响应数据
    • 拉黑 IP
    • 深入解析 Tio 源码:构建高性能 Java 网络应用
  • 19_aio

    • ByteBuffer
    • AIO HTTP 服务器
    • 自定义和线程池和池化 ByteBuffer
    • AioHttpServer 应用示例 IP 属地查询
    • 手写 AIO Http 服务器
  • 20_netty

    • Netty TCP Server
    • Netty Web Socket Server
    • 使用 protoc 生成 Java 包文件
    • Netty WebSocket Server 二进制数据传输
    • Netty 组件详解
  • 21_netty-boot

    • Netty-Boot
    • 原理解析
    • 整合 Hot Reload
    • 整合 数据库
    • 整合 Redis
    • 整合 Elasticsearch
    • 整合 Dubbo
    • Listener
    • 文件上传
    • 拦截器
    • Spring Boot 整合 Netty-Boot
    • SSL 配置指南
    • ChannelInitializer
    • Reserve
  • 22_MQ

    • Mica-mqtt
    • EMQX
    • Disruptor
  • 23_tio-utils

    • tio-utils
    • HttpUtils
    • Notification
    • 邮箱
    • JSON
    • 读取文件
    • Base64
    • 上传和下载
    • Http
    • Telegram
    • RsaUtils
    • EnvUtils
    • 系统监控
    • 毫秒并发 ID (MCID) 生成方案
  • 24_tio-http-server

    • 使用 Tio-Http-Server 搭建简单的 HTTP 服务
    • tio-boot 添加 HttpRequestHandler
    • 在 Android 上使用 tio-boot 运行 HTTP 服务
    • tio-http-server-native
    • handler 常用操作
  • 25_tio-websocket

    • WebSocket 服务器
    • WebSocket Client
    • TCP数据转发
  • 26_tio-im

    • 通讯协议文档
    • ChatPacket.proto 文档
    • java protobuf
    • 数据表设计
    • 创建工程
    • 登录
    • 历史消息
    • 发消息
  • 27_mybatis

    • Tio-Boot 整合 MyBatis
    • 使用配置类方式整合 MyBatis
    • 整合数据源
    • 使用 mybatis-plus 整合 tdengine
    • 整合 mybatis-plus
  • 28_mongodb

    • tio-boot 使用 mongo-java-driver 操作 mongodb
  • 29_elastic-search

    • Elasticsearch
    • JavaDB 整合 ElasticSearch
    • Elastic 工具类使用指南
    • Elastic-search 注意事项
    • ES 课程示例文档
  • 30_magic-script

    • tio-boot 与 magic-script 集成指南
  • 31_groovy

    • tio-boot 整合 Groovy
  • 32_firebase

    • 整合 google firebase
    • Firebase Storage
    • Firebase Authentication
    • 使用 Firebase Admin SDK 进行匿名用户管理与自定义状态标记
    • 导出用户
    • 注册回调
    • 登录注册
  • 33_文件存储

    • 文件上传数据表
    • 本地存储
    • 使用 AWS S3 存储文件并整合到 Tio-Boot 项目中
    • 存储文件到 腾讯 COS
  • 34_spider

    • jsoup
    • 爬取 z-lib.io 数据
    • 整合 WebMagic
    • WebMagic 示例:爬取学校课程数据
    • Playwright
    • Flexmark (Markdown 处理器)
    • tio-boot 整合 Playwright
    • 缓存网页数据
  • 36_integration_thirty_party

    • tio-boot 整合 okhttp
    • 整合 GrpahQL
    • 集成 Mailjet
    • 整合 ip2region
    • 整合 GeoLite 离线库
    • 整合 Lark 机器人指南
    • 集成 Lark Mail 实现邮件发送
    • Thymeleaf
    • Swagger
    • Clerk 验证
  • 37_dubbo

    • 概述
    • dubbo 2.6.0
    • dubbo 2.6.0 调用过程
    • dubbo 3.2.0
  • 38_spring

    • Spring Boot Web 整合 Tio Boot
    • spring-boot-starter-webflux 整合 tio-boot
    • Tio Boot 整合 Spring Boot Starter
    • Tio Boot 整合 Spring Boot Starter Data Redis 指南
  • 39_spring-cloud

    • tio-boot spring-cloud
  • 40_mysql

    • 使用 Docker 运行 MySQL
    • /zh/42_mysql/02.html
  • 41_postgresql

    • PostgreSQL 安装
    • PostgreSQL 主键自增
    • PostgreSQL 日期类型
    • Postgresql 金融类型
    • PostgreSQL 数组类型
    • PostgreSQL 全文检索
    • PostgreSQL 查询优化
    • 获取字段类型
    • PostgreSQL 向量
    • PostgreSQL 优化向量查询
    • PostgreSQL 其他
  • 43_oceanbase

    • 快速体验 OceanBase 社区版
    • 快速上手 OceanBase 数据库单机部署与管理
    • 诊断集群性能
    • 优化 SQL 性能指南
    • /zh/43_oceanbase/05.html
  • 50_media

    • JAVE 提取视频中的声音
    • Jave 提取视频中的图片
    • /zh/50_media/03.html
  • 51_asr

    • Whisper-JNI
  • 54_native-media

    • java-native-media
    • JNI 入门示例
    • mp3 拆分
    • mp4 转 mp3
    • 使用 libmp3lame 实现高质量 MP3 编码
    • Linux 编译
    • macOS 编译
    • 从 JAR 包中加载本地库文件
    • 支持的音频和视频格式
    • 任意格式转为 mp3
    • 通用格式转换
    • 通用格式拆分
    • 视频合并
    • VideoToHLS
    • split_video_to_hls 支持其他语言
    • 持久化 HLS 会话
  • 55_telegram4j

    • 数据库设计
    • /zh/55_telegram4j/02.html
    • 基于 MTProto 协议开发 Telegram 翻译机器人
    • 过滤旧消息
    • 保存机器人消息
    • 定时推送
    • 增加命令菜单
    • 使用 telegram-Client
    • 使用自定义 StoreLayout
    • 延迟测试
    • Reactor 错误处理
    • Telegram4J 常见错误处理指南
  • 56_telegram-bots

    • TelegramBots 入门指南
    • 使用工具库 telegram-bot-base 开发翻译机器人
  • 60_LLM

    • 简介
    • AI 问答
    • /zh/60_LLM/03.html
    • /zh/60_LLM/04.html
    • 增强检索(RAG)
    • 结构化数据检索
    • 搜索+AI
    • 集成第三方 API
    • 后置处理
    • 推荐问题生成
    • 连接代码执行器
    • 避免 GPT 混乱
    • /zh/60_LLM/13.html
  • 61_ai_agent

    • 数据库设计
    • 示例问题管理
    • 会话管理
    • 历史记录
    • Perplexity API
    • 意图识别
    • 智能问答
    • 文件上传与解析文档
    • 翻译
    • 名人搜索功能实现
    • Ai studio gemini youbue 问答使用说明
    • 自建 YouTube 字幕问答系统
    • 自建 获取 youtube 字幕服务
    • 通用搜索
    • /zh/61_ai_agent/15.html
    • 16
    • 17
    • 18
    • 在 tio-boot 应用中整合 ai-agent
    • 16
  • 62_translator

    • 简介
  • 63_knowlege_base

    • 数据库设计
    • 用户登录实现
    • 模型管理
    • 知识库管理
    • 文档拆分
    • 片段向量
    • 命中测试
    • 文档管理
    • 片段管理
    • 问题管理
    • 应用管理
    • 向量检索
    • 推理问答
    • 问答模块
    • 统计分析
    • 用户管理
    • api 管理
    • 存储文件到 S3
    • 文档解析优化
    • 片段汇总
    • 段落分块与检索
    • 多文档解析
    • 对话日志
    • 检索性能优化
    • Milvus
    • 文档解析方案和费用对比
    • 离线运行向量模型
  • 64_ai-search

    • ai-search 项目简介
    • ai-search 数据库文档
    • ai-search SearxNG 搜索引擎
    • ai-search Jina Reader API
    • ai-search Jina Search API
    • ai-search 搜索、重排与读取内容
    • ai-search PDF 文件处理
    • ai-search 推理问答
    • Google Custom Search JSON API
    • ai-search 意图识别
    • ai-search 问题重写
    • ai-search 系统 API 接口 WebSocket 版本
    • ai-search 搜索代码实现 WebSocket 版本
    • ai-search 生成建议问
    • ai-search 生成问题标题
    • ai-search 历史记录
    • Discover API
    • 翻译
    • Tavily Search API 文档
    • 对接 Tavily Search
    • 火山引擎 DeepSeek
    • 对接 火山引擎 DeepSeek
    • ai-search 搜索代码实现 SSE 版本
    • jar 包部署
    • Docker 部署
    • 爬取一个静态网站的所有数据
    • 网页数据预处理
    • 网页数据检索与问答流程整合
  • 65_java-kit-server

    • Java 执行 python 代码
    • 通过大模型执行 Python 代码
    • MCP 协议
    • Cline 提示词
    • Cline 提示词-中文版本
  • 66_manim

    • Teach me anything - 基于大语言的知识点讲解视频生成系统
    • Manim 开发环境搭建
    • 生成场景提示词
    • 生成代码
    • 完整脚本示例
    • 语音合成系统
    • Fish.audio TTS 接口说明文档与 Java 客户端封装
    • 整合 fishaudio 到 java-uni-ai-server 项目
    • 执行 Python (Manim) 代码
    • 使用 SSE 流式传输生成进度的实现文档
    • 整合全流程完整文档
    • HLS 动态推流技术文档
    • manim 分场景生成代码
    • 分场景运行代码及流式播放支持
    • 分场景业务端完整实现流程
    • Maiim布局管理器
    • 仅仅生成场景代码
    • 使用 modal 运行 manim 代码
    • Python 使用 Modal GPU 加速渲染
    • Modal 平台 GPU 环境下运行 Manim
    • Modal Manim OpenGL 安装与使用
    • 优化 GPU 加速
    • 生成视频封面流程
    • Java 调用 manim 命令 执行代码 生成封面
    • Manim 图像生成服务客户端文档
    • manim render help
    • 显示 中文公式
    • manimgl
    • EGL
    • /zh/66_manim/30.html
    • /zh/66_manim/31.html
    • /zh/66_manim/32.html
    • /zh/66_manim/33.html
  • 68_java-llm-proxy

    • 使用tio-boot搭建多模型LLM代理服务
  • 69_ai-brower

    • AI Browser:基于用户指令的浏览器自动化系统
    • 提示词
    • dom构建- buildDomTree.js
    • dom构建- 将网页可点击元素提取与可视化
    • 提取网内容
    • 启动浏览器
    • 操作浏览器指令
  • 70_tio-boot-admin

    • 入门指南
    • 初始化数据
    • token 存储
    • 与前端集成
    • 文件上传
    • 网络请求
    • 图片管理
    • /zh/70_tio-boot-admin/08.html
    • Word 管理
    • PDF 管理
    • 文章管理
    • 富文本编辑器
  • 71_tio-boot

    • /zh/71_tio-boot/01.html
    • Swagger 整合到 Tio-Boot 中的指南
    • HTTP/1.1 Pipelining 性能测试报告
  • 73_tio-mail-wing

    • tio-mail-wing简介
    • 任务1:实现POP3系统
    • 使用 getmail 验证 tio-mail-wing POP3 服务
    • 任务2:实现 SMTP 服务
    • 数据库初始化文档
    • 用户管理
    • 邮件管理
    • 任务3:实现 SMTP 服务 数据库版本
    • 任务4:实现 POP3 服务(数据库版本)
    • IMAP 协议
    • 拉取多封邮件
    • 任务5:实现 IMAP 服务(数据库版本)
    • IMAP实现讲解
    • IMAP 手动测试脚本
    • IMAP 认证机制
    • 主动推送
  • 80_性能测试

    • 压力测试 - tio-http-serer
    • 压力测试 - tio-boot
    • 压力测试 - tio-boot-native
    • 压力测试 - netty-boot
    • 性能测试对比
    • TechEmpower FrameworkBenchmarks
    • 压力测试 - tio-boot 12 C 32G
  • 99_案例

    • 封装 IP 查询服务
    • tio-boot 案例 - 全局异常捕获与企业微信群通知
    • tio-boot 案例 - 文件上传和下载
    • tio-boot 案例 - 整合 ant design pro 增删改查
    • tio-boot 案例 - 流失响应
    • tio-boot 案例 - 增强检索
    • tio-boot 案例 - 整合 function call
    • tio-boot 案例 - 定时任务 监控 PostgreSQL、Redis 和 Elasticsearch
    • Tio-Boot 案例:使用 SQLite 整合到登录注册系统
    • tio-boot 案例 - 执行 shell 命令

注册和登录

1.接口

1.1 注册(Regisater)

1.1.1 前端请求

当用户提交注册信息时,前端将用户名(邮箱)和密码发送给后端,后端负责处理注册逻辑并发送邮箱验证链接。

前端请求参数:

  • email: 用户的邮箱地址。
  • password: 用户的密码。

前端请求示例:

POST /api/v1/register
Content-Type: application/json
Origin: http://localhost:8100

{
  "username":"user",
  "email": "user@example.com",
  "password": "userpassword"
  "user_type": 1
  "verification_type":0
  "user_id":"id" //可选
}

Origin 如果进行邮箱验证,是必填信息,通常浏览器会自动携带 user_type 根据业务需求自定义,示例中 0 匿名 1 普通用户 2 高级用户 verification_type 验证类型 0 不验证邮箱 1 验证码验证 2 链接验证 user_id是用户的id,如果从匿名接口获取了id则填写

1.1.2 后端处理逻辑

后端接收到注册请求后,创建用户,并发送邮箱验证链接。如果注册成功,返回注册成功状态,并告知前端验证邮件已发送。

后端返回示例:

{ "data": null, "ok": true, "msg": null, "code": 1 }

如果注册失败会返回

{
    "code": 0,
    "msg": null,
    "ok": false,
    "error": null,
    "data": [
        {
            "field": "password",
            "messages": [
                "Failed to valiate password:00000000"
            ]
        }
    ]
}

此时需要对password标红,并并显示messages中的信息

1.1.3 前端处理逻辑

前端接收到成功响应后,提示用户验证邮件已发送,并引导用户查看邮箱进行验证。

1.1.4 用户验证

用户打开邮箱,邮箱内容示例如下.链接进行验证,验证通过后 会自动跳转到下面的前端地址 正式环境中 localhost:8100 是前端的域名

Dear User,

Thank you for signing up for College Bot AI!

Please verify your email address by clicking the link below:
http://localhost:8100/verification/email?email=litongjava001@gmail.com&code=358412

This will ensure your account is secure and fully activated.

If you did not request this verification, please disregard this email.

Best regards,
The College Bot AI Team

用户打开邮箱后会点击上面的地址,前端应该使用一个路由拦截到上面的地址并获取 email 和 code 参数,并请后端发送请求确认验证码有效, 验证失败前端自行处理失败,例如显示失败信息 验证成功的前端跳转到登录地址

/api/v1/login?role={instructor|student} 统一为小写

1.2. 登录(Login)

1.2.1 前端请求

当用户提交登录信息时,前端将邮箱和密码发送到后端,后端完成身份验证并返回用户的 idToken

前端请求参数:

  • email: 用户的邮箱地址。
  • password: 用户的密码。

前端请求示例:

POST /api/v1/login
Content-Type: application/json

{
  "email": "user@example.com",
  "password": "userpassword"
}

1.2.2 后端处理逻辑

后端进行登录验证。登录成功后,生成并返回 idToken 给前端。

后端返回参数:

  • idToken: idToken。
  • expires_in: 令牌过期时间,单位秒

后端返回示例(登录成功):

响应数据示例

{
  "data": {
    "user_id":"user_id",
    "display_name": "Tong Li",
    "email": "litongjava001@gmail.com",
    "refresh_token":"token",
    "token": "token",
    "expires_in": xxx
  },
  "code": 1,
  "msg": null,
  "ok": true
}
{
  "data": {
    "user_id": "488388937360424960",
    "display_name": "Tong Li",
    "email": "litongjava001@gmail.com",
    "phone": null,
    "photo_url": "https://lh3.googleusercontent.com/a/ACg8ocKy5qtXCrfvGrNoyhGY_Jv8b3aF9GcBXxoAO85RVNLNg88dpCw=s96-c",
    "refresh_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOi0xLCJ1c2VySWQiOiI0ODgzODg5MzczNjA0MjQ5NjAifQ==.VaziGyn3ellkiFChfWuU0m70mybJKN-yRtPKC0Twp78",
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3NDI0OTY2NTAsInVzZXJJZCI6IjQ4ODM4ODkzNzM2MDQyNDk2MCJ9.bKHkuneji6zlS10bWLcZT-71Hhm7aWlv11FRSahftv8",
    "expires_in": 1742496650
  },
  "ok": true,
  "code": 1,
  "msg": null,
  "error": null
}

1.2.3 前端处理逻辑

前端接收到 idToken 后,后续请求如果需在请求头中携带该 token:格式为

authorization: Bearer {token}

1.3 验证接口

http://localhost:8100/api/v1/verify?email=litongjava001@gmail.com&code=358412

1.4 刷新 token

携带 token

POST /api/v1/user/refresh
{
    "refresh_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOi0xLCJ1c2VySWQiOiI0ODgyMzYyNzIzMzg4NzAyNzIifQ==.a2Nipd4YQc0DQ4S5lUlFVrh6Xn_GuI4qBbFS7yRddIQ"
}
{
  "data": {
    "user_id": "488236272338870272",
    "expires_in": 604800,
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjYwNDgwMCwidXNlcklkIjoiNDg4MjM2MjcyMzM4ODcwMjcyIn0=.fCbcrxdxgpbdC81wS3nPRMRyuKA0_G7iTyBfH5qOF2w"
  },
  "error": null,
  "ok": true,
  "code": 1,
  "msg": null
}

1.5 登出用户

退出当前系统的登录 注意:系统采用 单 Token 设计,后端不会存储后端 token,退出登录后上次生成的 token 依旧有效,所以用户登出实际上不用调用任何接口,前端将 token 删除即可.如果考虑后续的扩展,前端可以使用该接口

GET /api/v1/logout
Authorization:Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3NDIwODgzNjgsInVzZXJJZCI6IjQ4ODIzNjI3MjMzODg3MDI3MiJ9.liKfYdWzULDPCeKfktyKyEanZIO3Q7uhZ9mAKMfjWyM

1.6 删除用户

从系统中删除该用户

GET /api/v1/user/remove
Authorization:Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3NDIwODgzNjgsInVzZXJJZCI6IjQ4ODIzNjI3MjMzODg3MDI3MiJ9.liKfYdWzULDPCeKfktyKyEanZIO3Q7uhZ9mAKMfjWyM

下面给出一套基于 Java(Tio-boot 框架风格)的示例实现,包含注册、登录、发送邮件以及邮箱验证码验证等接口。示例代码中保留了 SQL 建表语句和详细注释,便于理解各个步骤的逻辑。注意:以下代码仅为示例,实际项目中需要根据项目情况进行完善(如密码加盐算法、Token 生成逻辑、异常处理等)。


2. 后端代码实现

下面实现注册、登录、发送验证邮件及邮箱验证逻辑。整体采用类似 Tio-boot 的 Handler 方式实现。

2.1 注册接口

当用户提交注册请求时,系统完成用户信息存储(密码进行加盐和哈希处理),同时调用发送邮件接口生成验证码记录并发送验证链接。

2.1.1 请求对象

package com.litongjava.tio.boot.admin.vo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class AppUserRegisterRequest {
  private String email;
  private String password;
  private int userType; // 0:匿名,1:普通, 2:高级
  private int verification_type; //0 不验证邮箱 1 验证码验证 2 链接验证
  private Long userId;
}

2.1.2 注册 Handler

package com.litongjava.tio.boot.admin.handler;

import java.util.ArrayList;
import java.util.List;

import com.litongjava.jfinal.aop.Aop;
import com.litongjava.model.body.RespBodyVo;
import com.litongjava.model.validate.ValidateResult;
import com.litongjava.tio.boot.admin.services.AppEmailService;
import com.litongjava.tio.boot.admin.services.AppUserService;
import com.litongjava.tio.boot.admin.vo.AppUserRegisterRequest;
import com.litongjava.tio.boot.http.TioRequestContext;
import com.litongjava.tio.http.common.HttpRequest;
import com.litongjava.tio.http.common.HttpResponse;
import com.litongjava.tio.utils.hutool.StrUtil;
import com.litongjava.tio.utils.json.Json;
import com.litongjava.tio.utils.validator.EmailValidator;
import com.litongjava.tio.utils.validator.PasswordValidator;

public class AppUserRegisterHandler {
  AppUserService appUserService = Aop.get(AppUserService.class);

  public HttpResponse register(HttpRequest request) {
    String origin = request.getOrigin();
    HttpResponse response = TioRequestContext.getResponse();
    String body = request.getBodyString();

    List<ValidateResult> validateResults = new ArrayList<>();
    boolean ok = true;
    if (StrUtil.isEmpty(origin)) {
      ValidateResult validateResult = ValidateResult.by("origin", "Failed to valiate origin:" + origin);
      validateResults.add(validateResult);
      ok = false;
    }

    // 解析注册请求参数
    AppUserRegisterRequest req = Json.getJson().parse(body, AppUserRegisterRequest.class);
    String email = req.getEmail();
    boolean validate = EmailValidator.validate(email);
    if (!validate) {
      ValidateResult validateResult = ValidateResult.by("eamil", "Failed to valiate email:" + email);
      validateResults.add(validateResult);
      ok = false;
    }

    String password = req.getPassword();
    validate = PasswordValidator.validate(password);
    if (!validate) {
      ValidateResult validateResult = ValidateResult.by("password", "Failed to valiate password:" + password);
      validateResults.add(validateResult);
      ok = false;
    }

    if (!ok) {
      return response.setJson(RespBodyVo.failData(validateResults));
    }

    boolean exists = appUserService.existsEmail(email);
    if (exists) {
      ValidateResult validateResult = ValidateResult.by("eamil", "eamil already taken" + email);
      validateResults.add(validateResult);
    }

    if (!ok) {
      return response.setJson(RespBodyVo.failData(validateResults));
    }

    boolean success = false;
    Long userId = req.getUserId();
    if (userId != null && appUserService.exists(userId.toString())) {
      success = appUserService.registerUserByUserId(req, origin);
    } else {
      // 注册用户(内部会处理密码加盐和哈希等逻辑)
      success = appUserService.registerUser(req.getEmail(), req.getPassword(), req.getUserType(), origin);
    }

    if (success) {
      if (req.getVerification_type() == 1) {
        // 注册成功后发送验证邮件(验证码及链接)
        AppEmailService emailService = Aop.get(AppEmailService.class);
        boolean sent = emailService.sendVerificationCodeEmail(req.getEmail(), origin);
        if (sent) {
          return response.setJson(RespBodyVo.ok());
        } else {
          return response.setJson(RespBodyVo.fail("Failed to send email"));
        }
      } else if (req.getVerification_type() == 2) {
        // 注册成功后发送验证邮件(验证码及链接)
        AppEmailService emailService = Aop.get(AppEmailService.class);
        boolean sent = emailService.sendVerificationEmail(req.getEmail(), origin);
        if (sent) {
          return response.setJson(RespBodyVo.ok());
        } else {
          return response.setJson(RespBodyVo.fail("Failed to send email"));
        }
      } else {
        return response.setJson(RespBodyVo.ok());
      }
    } else {
      return response.setJson(RespBodyVo.fail());
    }
  }
}

2.2 登录接口

登录时前端提交邮箱和密码。后端进行密码校验后生成 Token(及 refreshToken),不再强制要求邮箱验证(即使 email_verified 为 false,也允许登录)。

2.2.1 请求对象

package com.litongjava.tio.boot.admin.vo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@NoArgsConstructor
@AllArgsConstructor
@Data
public class AppUserLoginRequest {
  private String email;
  private String password;
}

2.2.2 返回对象

package com.litongjava.tio.boot.admin.vo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class AppUserLoginVo {

  private String user_id;
  private String display_name;
  private String email;
  private String phone;
  private String photo_url;
  private String refresh_token;
  private String token;
  private Integer expires_in;

  public AppUserLoginVo(String userId, String displayName, String refreshToken, String token, int expires_in) {
    this.user_id = userId;
    this.display_name = displayName;
    this.refresh_token = refreshToken;
    this.token = token;
    this.expires_in = expires_in;
  }

  public AppUserLoginVo(String userId, String displayName, String email, String photo_url, String refreshToken, String token, int expires_in) {
    this.user_id = userId;
    this.display_name = displayName;
    this.email = email;
    this.photo_url = photo_url;
    this.refresh_token = refreshToken;
    this.token = token;
    this.expires_in = expires_in;
  }
}

2.2.3 登录 Handler

package com.litongjava.tio.boot.admin.handler;

import com.litongjava.jfinal.aop.Aop;
import com.litongjava.model.body.RespBodyVo;
import com.litongjava.tio.boot.admin.services.AppUserService;
import com.litongjava.tio.boot.admin.vo.AppUser;
import com.litongjava.tio.boot.admin.vo.AppUserLoginRequest;
import com.litongjava.tio.boot.admin.vo.AppUserLoginVo;
import com.litongjava.tio.boot.http.TioRequestContext;
import com.litongjava.tio.http.common.HttpRequest;
import com.litongjava.tio.http.common.HttpResponse;
import com.litongjava.tio.utils.environment.EnvUtils;
import com.litongjava.tio.utils.json.JsonUtils;

public class AppUserLoginHandler {
  public HttpResponse login(HttpRequest request) {
    HttpResponse response = TioRequestContext.getResponse();
    String body = request.getBodyString();
    AppUserLoginRequest req = JsonUtils.parse(body, AppUserLoginRequest.class);

    AppUserService appUserService = Aop.get(AppUserService.class);
    AppUser user = appUserService.getUserByEmail(req.getEmail());
    // 此处允许未验证邮箱的用户登录
    if (user != null && appUserService.verifyPassword(user, req.getPassword())) {
      // 生成 token,有效期 7 天(604800秒)
      Long timeout = EnvUtils.getLong("app.token.timeout", 604800L);
      Long tokenTimeout = System.currentTimeMillis() / 1000 + timeout;
      String userId = user.getId();
      String token = appUserService.createToken(userId, tokenTimeout);
      String refreshToken = appUserService.createRefreshToken(userId);

      AppUserLoginVo appUserLoginVo = new AppUserLoginVo(userId, user.getDisplayName(), req.getEmail(), refreshToken, token, tokenTimeout.intValue());

      return response.setJson(RespBodyVo.ok(appUserLoginVo));
    }
    return response.setJson(RespBodyVo.fail("username or password is not correct"));
  }

  public HttpResponse logout(HttpRequest request) {
    HttpResponse response = TioRequestContext.getResponse();
    String userId = TioRequestContext.getUserIdString();

    AppUserService appUserService = Aop.get(AppUserService.class);
    boolean logout = appUserService.logout(userId);
    if (logout) {
      response.setJson(RespBodyVo.ok());
    } else {
      response.setJson(RespBodyVo.fail());
    }
    return response;

  }
}

2.3 用户接口

package com.litongjava.tio.boot.admin.handler;

import com.jfinal.kit.Kv;
import com.litongjava.jfinal.aop.Aop;
import com.litongjava.model.body.RespBodyVo;
import com.litongjava.tio.boot.admin.costants.AppConstant;
import com.litongjava.tio.boot.admin.services.AppUserService;
import com.litongjava.tio.boot.admin.vo.AppUser;
import com.litongjava.tio.boot.admin.vo.UserResetPasswordRequest;
import com.litongjava.tio.boot.http.TioRequestContext;
import com.litongjava.tio.http.common.HttpRequest;
import com.litongjava.tio.http.common.HttpResponse;
import com.litongjava.tio.utils.environment.EnvUtils;
import com.litongjava.tio.utils.json.FastJson2Utils;
import com.litongjava.tio.utils.json.JsonUtils;
import com.litongjava.tio.utils.jwt.JwtUtils;

public class AppUserHandler {
  public HttpResponse refresh(HttpRequest request) {
    HttpResponse response = TioRequestContext.getResponse();
    String bodyString = request.getBodyString();
    String refresh_token = FastJson2Utils.parseObject(bodyString).getString("refresh_token");

    String key = EnvUtils.getStr(AppConstant.ADMIN_SECRET_KEY);
    boolean verify = JwtUtils.verify(key, refresh_token);
    if (verify) {
      String userId = JwtUtils.parseUserIdString(refresh_token);
      AppUserService appUserService = Aop.get(AppUserService.class);
      // 生成 token,有效期 7 天(604800秒)
      Long timeout = EnvUtils.getLong("app.token.timeout", 604800L);
      Long tokenTimeout = System.currentTimeMillis() / 1000 + timeout;
      String token = appUserService.createToken(userId, tokenTimeout);
      Kv kv = Kv.by("user_id", userId).set("token", token).set("expires_in", tokenTimeout.intValue());
      response.setJson(RespBodyVo.ok(kv));
    } else {
      response.setJson(RespBodyVo.fail("Failed to validate refresh_token"));
    }
    return response;
  }

  public HttpResponse remove(HttpRequest request) {
    HttpResponse response = TioRequestContext.getResponse();
    String userIdString = TioRequestContext.getUserIdString();
    AppUserService appUserService = Aop.get(AppUserService.class);
    boolean ok = appUserService.remove(userIdString);
    if (ok) {
      response.setJson(RespBodyVo.ok());
    } else {
      response.setJson(RespBodyVo.fail());
    }
    return response;
  }

  public HttpResponse resetPassword(HttpRequest request) {
    HttpResponse response = TioRequestContext.getResponse();
    String bodyString = request.getBodyString();
    UserResetPasswordRequest userResetPassword = JsonUtils.parse(bodyString, UserResetPasswordRequest.class);

    AppUserService appUserService = Aop.get(AppUserService.class);
    RespBodyVo vo = appUserService.resetPassword(userResetPassword);
    return response.setJson(vo);
  }
  
  public HttpResponse profile(HttpRequest request) {
    String userIdString = TioRequestContext.getUserIdString();
    AppUserService appUserService = Aop.get(AppUserService.class);
    AppUser user = appUserService.getUserById(userIdString);
    HttpResponse response = TioRequestContext.getResponse();
    return response.setJson(RespBodyVo.ok(user));
    
  }
}

3. 服务层实现

3.1 admin_app_user.sql

--# app_users.findById
SELECT id,
  email,
  phone,
  email_verified,
  updated_profile,
  display_name,
  bio,
  photo_url,
  background_url,
  phone_number,
  disabled,
  birthday,
  coin,
  invited_by_user_id,
  "of",
  platform,
  third_platform_url,
  school_id,
  user_type,
  provider_data,
  mfa_info,
  metadata,
  user_info,
  google_id,
  google_info,
  facebook_id,
  facebook_info,
  twitter_id,
  twitter_info,
  github_id,
  github_info,
  wechat_id,
  wechat_info,
  qq_id,
  qq_info,
  weibo_id,
  weibo_info,
  remark,
  creator,
  create_time,
  updater,
  update_time,
  deleted,
  tenant_id 
FROM
  app_users 
WHERE
  ID = ?
  AND deleted = 0;

3.2 用户服务(AppUserService)

负责用户注册、密码验证、用户查询等操作。注意:此处示例使用简单的密码加密(SHA-256),实际项目中可采用更安全的加盐算法。

package com.litongjava.tio.boot.admin.services;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.codec.digest.DigestUtils;

import com.litongjava.db.activerecord.Db;
import com.litongjava.jfinal.aop.Aop;
import com.litongjava.model.body.RespBodyVo;
import com.litongjava.model.validate.ValidateResult;
import com.litongjava.template.SqlTemplates;
import com.litongjava.tio.boot.admin.costants.AppConstant;
import com.litongjava.tio.boot.admin.costants.TioBootAdminTableNames;
import com.litongjava.tio.boot.admin.vo.AppUser;
import com.litongjava.tio.boot.admin.vo.AppUserRegisterRequest;
import com.litongjava.tio.boot.admin.vo.UserResetPasswordRequest;
import com.litongjava.tio.boot.admin.vo.UserToken;
import com.litongjava.tio.utils.environment.EnvUtils;
import com.litongjava.tio.utils.jwt.JwtUtils;
import com.litongjava.tio.utils.snowflake.SnowflakeIdUtils;
import com.litongjava.tio.utils.validator.EmailValidator;
import com.litongjava.tio.utils.validator.PasswordValidator;

public class AppUserService {

  // 查询用户基本信息(不含密码相关字段),自动映射下划线到驼峰
  private static final String SQL_SELECT_USER = SqlTemplates.get("app_users.findById");

  // 仅查询密码盐与哈希
  private static final String SQL_SELECT_PASSWORD = "SELECT id, password_salt, password_hash FROM app_users WHERE id = ? AND deleted = 0";
  
  public boolean registerUserByUserId(AppUserRegisterRequest req, String origin) {
    String password = req.getPassword();
    String email = req.getEmail();
    int lastIndex = email.lastIndexOf("@");
    String displayName = null;
    if (lastIndex > 0) {
      displayName = email.substring(0, lastIndex);
    } else {
      displayName = email;
    }
    int userType = req.getUserType();
    boolean exists = Db.exists(TioBootAdminTableNames.app_users, "email", email);
    if (exists) {
      return true;
    }
    // 生成加盐字符串(示例中直接使用随机数,实际可使用更复杂逻辑)
    String salt = String.valueOf(System.currentTimeMillis());
    // 生成密码哈希(密码+盐)
    String passwordHash = DigestUtils.sha256Hex(password + salt);

    // 插入用户记录(id 这里简单采用 email 作为唯一标识)
    long id = SnowflakeIdUtils.id();
    String insertSql = "update app_users set display_name=?, email=?, password_salt=?, password_hash=?, user_type=?,of=? where id=?";
    int rows = Db.updateBySql(insertSql, displayName, email, salt, passwordHash, userType, origin, id + "");
    return rows > 0;
  }

  // 注册用户:先检查邮箱是否已存在,然后插入用户记录
  public boolean registerUser(String email, String password, int userType, String orgin) {
    boolean exists = Db.exists(TioBootAdminTableNames.app_users, "email", email);
    if (exists) {
      return true;
    }
    int lastIndex = email.lastIndexOf("@");
    String displayName = null;
    if (lastIndex > 0) {
      displayName = email.substring(0, lastIndex);
    } else {
      displayName = email;
    }

    // 生成加盐字符串(示例中直接使用随机数,实际可使用更复杂逻辑)
    String salt = String.valueOf(System.currentTimeMillis());
    // 生成密码哈希(密码+盐)
    String passwordHash = DigestUtils.sha256Hex(password + salt);

    // 插入用户记录(id 这里简单采用 email 作为唯一标识)
    long id = SnowflakeIdUtils.id();
    String insertSql = "INSERT INTO app_users (id, display_name,email, password_salt, password_hash, user_type,of) VALUES (?,?,?,?,?,?,?)";
    int rows = Db.updateBySql(insertSql, id + "", displayName, email, salt, passwordHash, userType, orgin);
    return rows > 0;
  }

  // 根据邮箱获取用户信息
  public AppUser getUserByEmail(String email) {
    String sql = "SELECT * FROM app_users WHERE email=? AND deleted=0";
    return Db.findFirst(AppUser.class, sql, email);
  }


  public AppUser getUserById(Long userId) {
    return Db.findFirst(AppUser.class, SQL_SELECT_USER, userId);
  }

  public AppUser getUserById(String userIdString) {
    return Db.findFirst(AppUser.class, SQL_SELECT_USER, userIdString);
  }

  public AppUser getUserPasswordById(Long userId) {
    return Db.findFirst(AppUser.class, SQL_SELECT_PASSWORD, userId);
  }

  public AppUser getUserPasswordById(String userId) {
    return Db.findFirst(AppUser.class, SQL_SELECT_PASSWORD, userId);
  }

  // 校验用户密码
  public boolean verifyPassword(AppUser user, String password) {
    String salt = user.getPasswordSalt();
    String hash = DigestUtils.sha256Hex(password + salt);
    return hash.equals(user.getPasswordHash());
  }

  public boolean verifyPassword(String email, String password) {
    AppUser appUser = getUserByEmail(email);
    return verifyPassword(appUser, password);

  }

  public boolean verifyPassword(Long userId, String password) {
    AppUser appUser = getUserPasswordById(userId);
    return verifyPassword(appUser, password);
  }

  public String createToken(String id, Long timeout) {
    String key = EnvUtils.getStr(AppConstant.ADMIN_SECRET_KEY);
    return JwtUtils.createTokenByUserId(key, id, timeout);
  }

  public String createRefreshToken(String id) {
    String key = EnvUtils.getStr(AppConstant.ADMIN_SECRET_KEY);
    return JwtUtils.createTokenByUserId(key, id, -1);
  }

  public boolean logout(String userId) {
    return true;
  }

  public boolean remove(String userId) {
    //String sql = "update app_users set deleted=1 WHERE id=?";
    //Db.updateBySql(sql, userId);
    String sql = "delete from app_users WHERE id=?";
    Db.delete(sql, userId);
    return true;
  }

  public RespBodyVo resetPassword(UserResetPasswordRequest req) {

    List<ValidateResult> validateResults = new ArrayList<>();
    boolean ok = true;
    String email = req.getEmail();
    String code = req.getCode();
    boolean validate = EmailValidator.validate(email);
    if (!validate) {
      ValidateResult validateResult = ValidateResult.by("eamil", "Failed to valiate email:" + email);
      validateResults.add(validateResult);
      ok = false;
    }

    String password = req.getPassword();
    validate = PasswordValidator.validate(password);
    if (!validate) {
      ValidateResult validateResult = ValidateResult.by("password", "Failed to valiate password:" + password);
      validateResults.add(validateResult);
      ok = false;
    }

    if (!ok) {
      return RespBodyVo.failData(validateResults);
    }

    boolean exists = Db.exists(TioBootAdminTableNames.app_users, "email", email);
    if (exists) {
      ValidateResult validateResult = ValidateResult.by("eamil", "eamil already taken" + email);
      validateResults.add(validateResult);
    }

    if (!ok) {
      return RespBodyVo.failData(validateResults);
    }

    boolean verify = Aop.get(AppEmailService.class).verifyEmailCode(email, code);
    if (!verify) {
      return RespBodyVo.fail("Failed to verify code");
    }

    // 生成加盐字符串(示例中直接使用随机数,实际可使用更复杂逻辑)
    String salt = String.valueOf(System.currentTimeMillis());
    // 生成密码哈希(密码+盐)
    String passwordHash = DigestUtils.sha256Hex(password + salt);

    String updateSql = "update app_users set password_salt=?, password_hash=? where email=?";
    Db.updateBySql(updateSql, salt, passwordHash, email);
    return RespBodyVo.ok();
  }

  public RespBodyVo createAnonymousUser(String origin) {
    long longId = SnowflakeIdUtils.id();
    String userId = longId + "";
    String insertSql = "INSERT INTO app_users (id,of,user_type) VALUES (?,?,0)";

    Db.updateBySql(insertSql, userId, origin);

    // 生成 token,有效期 7 天(604800秒)
    Long timeout = EnvUtils.getLong("app.token.timeout", 604800L);
    Long tokenTimeout = System.currentTimeMillis() / 1000 + timeout;
    String token = createToken(userId, tokenTimeout);
    String refreshToken = createRefreshToken(userId);

    UserToken userToken = new UserToken(userId, token, tokenTimeout.intValue(), refreshToken, 0);
    return RespBodyVo.ok(userToken);
  }

  public boolean exists(String userId) {
    return Db.exists("app_users", "id", userId);
  }

  public boolean existsEmail(String email) {
    return Db.exists(TioBootAdminTableNames.app_users, "email", email);
  }

}

4. 路由配置

最后在路由配置中绑定各个接口。下面示例代码与 Tio-boot 的路由配置类似:

package com.example.app.config;

import com.example.app.handler.RegisterHandler;
import com.example.app.handler.LoginHandler;
import com.example.app.handler.EmailVerificationHandler;
import com.litongjava.tio.boot.server.TioBootServer;
import com.litongjava.tio.http.server.router.HttpRequestRouter;

public class AppHandlerConfiguration {
  public void config() {
    HttpRequestRouter router = TioBootServer.me().getRequestRouter();
    if (router == null) {
      return;
    }
    AppUserRegisterHandler appUserRegisterHandler = Aop.get(AppUserRegisterHandler.class);
    AppUserLoginHandler loginHandler = Aop.get(AppUserLoginHandler.class);
    EmailVerificationHandler emailVerificationHandler = Aop.get(EmailVerificationHandler.class);
    AppUserHandler appUserHandler = Aop.get(AppUserHandler.class);

    // 注册接口
    r.add("/api/v1/register", appUserRegisterHandler::register);
    // 登录接口
    r.add("/api/v1/login", loginHandler::login);
    //刷新
    r.add("/api/v1/user/refresh", appUserHandler::refresh);
    // 登出
    r.add("/api/v1/logout", loginHandler::logout);
    //删除
    r.add("/api/v1/user/remove", appUserHandler::remove);

    r.add("/api/v1/user/profile", appUserHandler::profile);
    // 发送验证码邮件接口
    r.add("/api/v1/sendVerification", emailVerificationHandler::sendVerification);
    // 邮箱验证接口
    r.add("/api/v1/verify", emailVerificationHandler::verifyEmail);
    r.add("/verification/email", emailVerificationHandler::verifyEmail);

  }
}

5.拦截器配置

package com.litongjava.tio.boot.admin.services;

import java.util.function.Predicate;

import com.litongjava.tio.boot.admin.costants.AppConstant;
import com.litongjava.tio.boot.http.TioRequestContext;
import com.litongjava.tio.utils.environment.EnvUtils;
import com.litongjava.tio.utils.jwt.JwtUtils;

public class TokenPredicate implements Predicate<String> {

  @Override
  public boolean test(String token) {
    String adminToken = EnvUtils.get(AppConstant.ADMIN_TOKEN);
    //system token
    boolean equals = adminToken.equals(token);
    if (equals) {
      TioRequestContext.setUserId(0L);
      return true;
    }
    // user and admin token
    String key = EnvUtils.getStr(AppConstant.ADMIN_SECRET_KEY);
    boolean verify = JwtUtils.verify(key, token);
    if (verify) {
      String userId = JwtUtils.parseUserIdString(token);
      TioRequestContext.setUserId(userId);
      return true;
    }
    return false;
  }

  public Long parseUserIdLong(String token) {
    String key = EnvUtils.getStr(AppConstant.ADMIN_SECRET_KEY);
    boolean verify = JwtUtils.verify(key, token);
    if (verify) {
      return JwtUtils.parseUserIdLong(token);
    }
    return null;
  }
}

设置 allow urls

model.addAllowUrls("/api/v1/login", "/api/v1/register", "/api/v1/user/refresh", "/api/v1/sendVerification", "/api/v1/verify", "/verification/email");
package com.litongjava.tio.boot.admin.config;

import java.util.function.Predicate;

import com.litongjava.tio.boot.admin.services.TokenPredicate;
import com.litongjava.tio.boot.http.interceptor.HttpInteceptorConfigure;
import com.litongjava.tio.boot.http.interceptor.HttpInterceptorModel;
import com.litongjava.tio.boot.server.TioBootServer;
import com.litongjava.tio.boot.token.AuthTokenInterceptor;

public class TioAdminInterceptorConfiguration {

  private String[] permitUrls;
  private boolean alloweStaticFile;
  private Predicate<String> validateTokenLogic;

  public TioAdminInterceptorConfiguration() {
  }

  public TioAdminInterceptorConfiguration(String[] permitUrls) {
    this.permitUrls = permitUrls;
  }

  public TioAdminInterceptorConfiguration(String[] permitUrls, Predicate<String> validateTokenLogic) {
    this.permitUrls = permitUrls;
    this.validateTokenLogic = validateTokenLogic;
  }

  public TioAdminInterceptorConfiguration(String[] permitUrls, boolean b) {
    this.permitUrls = permitUrls;
    this.alloweStaticFile = b;
  }

  public void config() {
    // 创建 SaToken 拦截器实例
    if (validateTokenLogic == null) {
      validateTokenLogic = new TokenPredicate();
    }

    AuthTokenInterceptor authTokenInterceptor = new AuthTokenInterceptor(validateTokenLogic);
    HttpInterceptorModel model = new HttpInterceptorModel();
    model.setInterceptor(authTokenInterceptor);
    model.addBlockUrl("/**"); // 拦截所有路由
    // index
    model.addAllowUrls("", "/");
    //user
    model.addAllowUrls("/register/*", "/api/login/account", "/api/login/outLogin"); // 设置例外路由
    model.addAllowUrls("/api/v1/login", "/api/v1/register", "/api/v1/user/refresh", "/api/v1/sendVerification", "/api/v1/verify", "/verification/email");
    model.addAllowUrls("/api/event/add");

    String[] previewUrls = { "/table/json/tio_boot_admin_system_article/get/*",
        //
        "/table/json/tio_boot_admin_system_docx/get/*", "/table/json/tio_boot_admin_system_pdf/get/*" };

    model.addAllowUrls(previewUrls);
    if (permitUrls != null) {
      model.addAllowUrls(permitUrls);
    }
    model.setAlloweStaticFile(alloweStaticFile);

    HttpInteceptorConfigure inteceptorConfigure = new HttpInteceptorConfigure();
    inteceptorConfigure.add(model);
    // 将拦截器配置添加到 Tio 服务器
    TioBootServer.me().setHttpInteceptorConfigure(inteceptorConfigure);
  }
}

8.邮件发送

lark.mail.host=smtp.larksuite.com
lark.mail.protocol=smtp
lark.mail.smpt.port=465
lark.mail.user=noreply@myget.ai
lark.mail.password=1111
lark.mail.from=no-reply

emails\register_mail.txt

Dear User,

Thank you for signing up for College Bot AI!

Please verify your email address by clicking the link below:
#(link)

This will ensure your account is secure and fully activated.

If you did not request this verification, please disregard this email.

Best regards,
The College Bot AI Team
com.litongjava.tio.boot.admin.config.TioAdminLarkSuitMailConfig.TioAdminLarkSuitMailConfig()
new TioAdminLarkSuitMailConfig().config();
package com.litongjava.myget.config;

import com.litongjava.annotation.AConfiguration;
import com.litongjava.annotation.Initialization;
import com.litongjava.jfinal.aop.Aop;
import com.litongjava.myget.email.MyGetEmailSender;
import com.litongjava.tio.boot.admin.config.*;
import com.litongjava.tio.boot.admin.handler.SystemFileTencentCosHandler;
import com.litongjava.tio.boot.server.TioBootServer;
import com.litongjava.tio.http.server.router.HttpRequestRouter;

@AConfiguration
public class AdminAppConfig {

  @Initialization
  public void config() {
    // 配置数据库相关
    new TioAdminDbConfiguration().config();
    new TioAdminRedisDbConfiguration().config();
    new TioAdminMongoDbConfiguration().config();
    new TioAdminInterceptorConfiguration().config();
    new TioAdminHandlerConfiguration().config();
    new TioAdminLarkSuitMailConfig().config();

    // 获取 HTTP 请求路由器
    TioBootServer server = TioBootServer.me();
    HttpRequestRouter r = server.getRequestRouter();
    if (r != null) {
      // 获取文件处理器,并添加文件上传和获取 URL 的接口
      SystemFileTencentCosHandler systemUploadHandler = Aop.get(SystemFileTencentCosHandler.class);
      r.add("/api/system/file/upload", systemUploadHandler::upload);
      r.add("/api/system/file/url", systemUploadHandler::getUrl);
    }

    server.setEmailSender(new MyGetEmailSender());

    // 配置控制器
    new TioAdminControllerConfiguration().config();
  }
}
package com.litongjava.myget.email;

import com.jfinal.kit.Kv;
import com.jfinal.template.Template;
import com.litongjava.myget.utils.MailJetUtils;
import com.litongjava.template.EmailEngine;
import com.litongjava.tio.boot.admin.mail.LarkSuitEmailUtils;
import com.litongjava.tio.boot.email.EmailSender;
import com.mailjet.client.MailjetResponse;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class MyGetEmailSender implements EmailSender {

  @Override
  public boolean send(String to, String subject, String content) {
    return false;
  }

  @Override
  public boolean sendVerificationEmail(String email, String origin, String code) {
    Template template = EmailEngine.getTemplate("register_mail.txt");
    String link = origin + "/verification/email?email=%s&code=%s";
    link = String.format(link, email, code);
    String content = template.renderToString(Kv.by("link", link));

    // 从邮箱地址中提取用户名作为收件人姓名
    String name = email.split("@")[0];

    String subject = "College Bot AI Email Verification";
    // 发送 HTML 格式的邀请邮件
    return sendWithLark(name, email, subject, content);
    //return sendWithMailjet(name, email, subject,content);
  }

  private boolean sendWithLark(String name, String email, String subject, String content) {
    try {
      LarkSuitEmailUtils.send(email, subject, content);
      return true;
    } catch (Exception e) {
      log.error(e.getMessage(), e);
      return false;
    }

  }

  private boolean sendWithMailjet(String name, String email, String subject, String content) {
    try {
      MailjetResponse response = MailJetUtils.sendText(name, email, subject, content);
      int status = response.getStatus();
      if (status == 200) {
        return true;
      } else {
        log.error(response.getRawResponseContent());
        return false;
      }
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
}

9.基本配置

admin.secret.key=123456
admin.token=123456
app.token.timeout=604800

10. 总结

  1. 注册:前端提交邮箱、密码和用户类型,后端完成用户记录创建(包含密码加盐与哈希),并调用邮件服务发送验证码。
  2. 登录:前端提交邮箱和密码,后端验证后生成 idToken(以及 refreshToken),即使邮箱未验证也允许登录。
  3. 邮箱验证码发送与验证:提供独立接口用于发送验证码邮件和验证验证码;验证成功后更新用户表中的邮箱验证状态。

以上示例实现了用户名密码注册和登录,并包含邮箱验证码发送和验证逻辑。所有代码均保留了原始逻辑和必要注释,方便直接参考和二次开发。

Edit this page
Last Updated:
Contributors: Tong Li
Prev
匿名登录
Next
个人中心