纲要
- 数据库准备与模型生成
- 用户表
user的 SQL 定义 - 使用
goctl model生成go-zero模型代码 - 模型扩展:新增根据手机号查询方法
FindOneByPhone
- 用户表
- 公共工具库构建
- 密码加密/验证:采用
bcrypt算法 JWT令牌生成:基于golang-jwt,自定义载荷与过期时间- 分布式 ID 生成:引入
sonyflake或类似组件生成全局唯一 ID
- 密码加密/验证:采用
- 服务配置定义
MySQL与Redis连接参数JWT密钥与过期时间配置
- 注册业务逻辑
- 手机号重复校验
- 可选密码加密
- 数据库写入与
JWT签发
- 登录业务逻辑
- 手机号存在性校验
- 密码比对
JWT签发
- 单元测试与 gRPC 验证
- 基于
svc.ServiceContext构建测试用例 - 通过 gRPC 客户端实际调用验证
- 基于
用户表设计与模型生成
在上一篇中,我们已完成了用户服务的脚手架搭建与部署自动化。本节将聚焦于注册、登录两个基础 API 的后端实现。
首先需要创建用户持久化表。在 deploy 目录下(或单独维护的 SQL 目录)新建 user.sql,内容如下:
CREATE TABLE `user` (
`id` bigint NOT NULL AUTO_INCREMENT,
`uid` varchar(64) NOT NULL DEFAULT '' COMMENT '用户唯一标识',
`phone` varchar(20) NOT NULL DEFAULT '' COMMENT '手机号',
`username` varchar(50) NOT NULL DEFAULT '' COMMENT '用户名',
`password` varchar(128) NOT NULL DEFAULT '' COMMENT '加密后的密码',
`avatar` varchar(255) NOT NULL DEFAULT '' COMMENT '头像',
`gender` tinyint(1) NOT NULL DEFAULT '0' COMMENT '性别',
`status` tinyint(1) NOT NULL DEFAULT '1' COMMENT '状态 1:正常 0:禁用',
`create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP,
`update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
PRIMARY KEY (`id`),
UNIQUE KEY `uk_phone` (`phone`),
KEY `idx_uid` (`uid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表';
因为后续模型需要在多个 RPC 或 API 服务中复用,将数据模型生成在公共位置更为合适。这里选择在 common/model/ 下执行 goctl 生成:
$ goctl model mysql ddl -c -src deploy/sql/user.sql -dir common/model -style goZero
执行后会在 common/model 下生成 usermodel.go 和 vars.go。生成的基础模型已经包含 FindOne、Insert 等方法。我们需要额外添加一个根据手机号查询的接口,在 usermodel.go 或新建 usermodel_ext.go 中补充:
package model
import (
"context"
"fmt"
"github.com/Masterminds/squirrel"
"github.com/zeromicro/go-zero/core/stores/sqlx"
)
// FindOneByPhone 根据手机号查询用户
func (m *defaultUserModel) FindOneByPhone(ctx context.Context, phone string) (*User, error) {
query := fmt.Sprintf("select %s from %s where phone = ? limit 1", userRows, m.table)
var resp User
err := m.conn.QueryRowCtx(ctx, &resp, query, phone)
if err != nil {
return nil, err
}
return &resp, nil
}
如果使用的是 goctl model mysql datasource -url ... -table user -dir ... 方式,方法签名可能略有不同,可以自行调整。
公共工具函数
在实现注册登录之前,将密码加密、JWT 生成以及 ID 生成三个组件封装到 common 中。
密码哈希
采用 golang.org/x/crypto/bcrypt,成本值通常为 10。
package crypt
import "golang.org/x/crypto/bcrypt"
func HashPassword(pwd string) (string, error) {
bytes, err := bcrypt.GenerateFromPassword([]byte(pwd), bcrypt.DefaultCost)
return string(bytes), err
}
func CheckPassword(hashed, pwd string) bool {
err := bcrypt.CompareHashAndPassword([]byte(hashed), []byte(pwd))
return err == nil
}
JWT 令牌生成
使用 github.com/golang-jwt/jwt/v4,定义载荷结构体,生成方法接收 uid、过期时长、密钥等参数。
package jwt
import (
"time"
jwt "github.com/golang-jwt/jwt/v4"
)
type Claims struct {
Uid string `json:"uid"`
jwt.RegisteredClaims
}
// GenerateToken 生成 JWT token
func GenerateToken(uid string, secretKey []byte, expireDuration time.Duration) (string, error) {
now := time.Now()
claims := Claims{
Uid: uid,
RegisteredClaims: jwt.RegisteredClaims{
ExpiresAt: jwt.NewNumericDate(now.Add(expireDuration)),
IssuedAt: jwt.NewNumericDate(now),
},
}
token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
return token.SignedString(secretKey)
}
签名方法采用 HS256,密钥配置在服务配置文件中,长度建议 32 字节以上。
分布式 ID 生成
为避免数据库自增 ID 的局限性,可以采用 sonyflake 或直接使用 github.com/rs/xid。这里以 sonyflake 为例生成全局唯一的 uid 字符串。
package uid
import (
"github.com/sony/sonyflake"
"strconv"
)
var flake = sonyflake.NewSonyflake(sonyflake.Settings{})
func NextID() (string, error) {
id, err := flake.NextID()
if err != nil {
return "", err
}
return strconv.FormatUint(id, 16), nil
}
配置项注入
在 apps/user/rpc/internal/config/config.go 中完善配置结构体,引入数据库、缓存以及 JWT 配置。
package config
import (
"github.com/zeromicro/go-zero/core/stores/cache"
"github.com/zeromicro/go-zero/core/stores/sqlx"
"github.com/zeromicro/go-zero/zrpc"
)
type Config struct {
zrpc.RpcServerConf
MySQL struct {
DataSource string
} `json:"mysql"`
CacheRedis cache.CacheConf `json:"cacheRedis"`
JWT struct {
Secret string `json:"secret"`
ExpireInSeconds int64 `json:"expireInSeconds"` // 秒
} `json:"jwt"`
}
对应的 etc/user.yaml 配置示例:
Name: user.rpc
ListenOn: 0.0.0.0:10001
Etcd:
Hosts:
- 192.168.1.10:2379
Key: user.rpc
MySQL:
DataSource: root:123456@tcp(192.168.1.10:3306)/im_db?charset=utf8mb4&parseTime=True&loc=Local
CacheRedis:
- Host: 192.168.1.10:6379
Pass: "your_redis_password"
JWT:
Secret: "your-secret-key-at-least-32-chars!"
ExpireInSeconds: 86400
在 svc.ServiceContext 中将数据库连接、模型与工具函数暴露给逻辑层。
package svc
import (
"github.com/zeromicro/go-zero/core/stores/sqlx"
"im-system/apps/user/rpc/internal/config"
"im-system/common/model"
)
type ServiceContext struct {
Config config.Config
UserModel model.UserModel
}
func NewServiceContext(c config.Config) *ServiceContext {
conn := sqlx.NewMysql(c.MySQL.DataSource)
return &ServiceContext{
Config: c,
UserModel: model.NewUserModel(conn, c.CacheRedis),
}
}
注册业务逻辑实现
注册的核心流程如下:
根据此流程,在 apps/user/rpc/internal/logic/registerLogic.go 中实现:
package logic
import (
"context"
"errors"
"time"
"im-system/apps/user/rpc/internal/svc"
"im-system/apps/user/rpc/user"
"im-system/common/crypt"
"im-system/common/jwt"
"im-system/common/uid"
"github.com/zeromicro/go-zero/core/logx"
)
type RegisterLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logx.Logger
}
func NewRegisterLogic(ctx context.Context, svcCtx *svc.ServiceContext) *RegisterLogic {
return &RegisterLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}
func (l *RegisterLogic) Register(in *user.RegisterRequest) (*user.RegisterResponse, error) {
// 1. 检查手机号是否已注册
existUser, err := l.svcCtx.UserModel.FindOneByPhone(l.ctx, in.Phone)
if err != nil && !errors.Is(err, sqlx.ErrNotFound) {
// 数据库查询异常
return nil, errors.New("内部错误")
}
if existUser != nil {
return nil, errors.New("手机号已注册")
}
// 2. 生成 uid
newUid, err := uid.NextID()
if err != nil {
return nil, errors.New("生成用户ID失败")
}
// 3. 构造用户对象
newUser := &model.User{
Uid: newUid,
Phone: in.Phone,
Username: in.Username,
Avatar: in.Avatar,
Gender: int64(in.Gender),
Status: 1,
}
// 4. 处理密码(如果传了密码则加密)
if len(in.Password) > 0 {
hashedPwd, err := crypt.HashPassword(in.Password)
if err != nil {
return nil, errors.New("密码加密失败")
}
newUser.Password = hashedPwd
}
// 5. 写入数据库
_, err = l.svcCtx.UserModel.Insert(l.ctx, newUser)
if err != nil {
return nil, errors.New("注册失败,请重试")
}
// 6. 生成 JWT
expire := time.Duration(l.svcCtx.Config.JWT.ExpireInSeconds) * time.Second
tokenStr, err := jwt.GenerateToken(newUid, []byte(l.svcCtx.Config.JWT.Secret), expire)
if err != nil {
return nil, errors.New("token生成失败")
}
return &user.RegisterResponse{
Uid: newUid,
Token: tokenStr,
}, nil
}
注意:RegisterRequest 中字段需与 proto 定义一致,此处假设有 Username、Avatar、Gender 等字段。
登录业务逻辑实现
登录流程:
在 apps/user/rpc/internal/logic/loginLogic.go 中实现:
package logic
import (
"context"
"errors"
"time"
"im-system/apps/user/rpc/internal/svc"
"im-system/apps/user/rpc/user"
"im-system/common/crypt"
"im-system/common/jwt"
"github.com/zeromicro/go-zero/core/logx"
)
type LoginLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logx.Logger
}
func NewLoginLogic(ctx context.Context, svcCtx *svc.ServiceContext) *LoginLogic {
return &LoginLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logx.WithContext(ctx),
}
}
func (l *LoginLogic) Login(in *user.LoginRequest) (*user.LoginResponse, error) {
// 1. 查询用户
u, err := l.svcCtx.UserModel.FindOneByPhone(l.ctx, in.Phone)
if err != nil {
return nil, errors.New("手机号未注册")
}
// 2. 校验密码
if !crypt.CheckPassword(u.Password, in.Password) {
return nil, errors.New("密码错误")
}
// 3. 生成 Token
expire := time.Duration(l.svcCtx.Config.JWT.ExpireInSeconds) * time.Second
tokenStr, err := jwt.GenerateToken(u.Uid, []byte(l.svcCtx.Config.JWT.Secret), expire)
if err != nil {
return nil, errors.New("生成token失败")
}
return &user.LoginResponse{
Uid: u.Uid,
Token: tokenStr,
}, nil
}
单元测试
go-zero 的 RPC 逻辑层天然支持单元测试,只需构造 ServiceContext 即可。
package logic
import (
"context"
"testing"
"im-system/apps/user/rpc/internal/config"
"im-system/apps/user/rpc/internal/svc"
"im-system/apps/user/rpc/user"
)
func TestRegisterLogic_Register(t *testing.T) {
// 加载测试配置
var c config.Config
// conf.MustLoad类似方法加载...此处简写
c = config.Config{
MySQL: struct{ DataSource string }{DataSource: "root:123456@tcp(192.168.1.10:3306)/im_db?charset=utf8mb4&parseTime=True"},
JWT: config.JWTConfig{Secret: "testsecret", ExpireInSeconds: 3600},
// 其他配置项...
}
svcCtx := svc.NewServiceContext(c)
// 测试注册
logic := NewRegisterLogic(context.Background(), svcCtx)
resp, err := logic.Register(&user.RegisterRequest{
Phone: "13700000001",
Username: "testuser",
Password: "123456",
Avatar: "",
Gender: 1,
})
if err != nil {
t.Fatalf("expected nil, got %v", err)
}
if resp.Token == "" {
t.Errorf("expected token not empty")
}
}
运行测试前确保测试数据库物理表已创建,并且 FindOneByPhone 方法正确。
启动与 gRPC 测试
服务启动:
$ cd apps/user/rpc
$ go run user.go -f etc/user.yaml
使用 grpcurl 或 Go 客户端调用 Register 和 Login 方法:
# 注册
$ grpcurl -plaintext -d '{"phone":"13700000001","username":"alice","password":"123456"}' 192.168.1.10:10001 user.User/Register
# 登录
$ grpcurl -plaintext -d '{"phone":"13700000001","password":"123456"}' 192.168.1.10:10001 user.User/Login
如果 go-zero 生成的服务监听了 0.0.0.0,在远程调用时需使用实际 IP,且注意 etcd 注册地址必须可被客户端寻址。
小结
至此,用户服务的核心注册与登录功能开发完毕。通过 goctl 快速生成数据模型,结合 bcrypt、JWT 等通用组件,我们构建了健壮且可复用的身份认证体系。后续社交服务与 IM 服务将直接依赖用户服务的 uid 与身份认证令牌,形成一个完整的微服务业务闭环。
在下一节中,我们将继续完善用户信息编辑、搜索等辅助接口,并引入 API 网关与 BFF 层对前端暴露统一的 HTTP 接口。
1574



被折叠的 条评论
为什么被折叠?



