【Go】九、API 编写测试_实现一个用户模块的接口

项目构建

New Project 直接创建项目，只需要起名字，之后在根目录中创建对应的微服务，这里先开发用户微服务模块：

mxshop_srvs

user_srv

global 公共内容

handler 服务

model 数据模型（表结构对应的模型）

proto 暴露接口

main.go 用来启动程序

数据模型创建

在 model 目录下 创建对应的文件：

model

user.go

main

main.go

user.go：

package model

import (
	"time"

	"gorm.io/gorm"
)

/*
*
公共表内容，所有的表都应该具有这几项，其他的 struct 都应该继承这个 struct
*/
type BaseModel struct {
	ID        int32     `gorm:"primarykey"`
	CreatedAt time.Time `gorm:"column:add_time"`
	UpdatedAt time.Time `gorm:"column:update_time"`
	DeletedAt gorm.DeletedAt
	IsDeleted bool
}

type User struct {
	BaseModel
	Mobile   string     `gorm:"index:idx_mobile;unique;type:varchar(11);not null"` // 为手机号添加索引、唯一约束、11位以下、非空
	Password string     `gorm:"type:varchar(100);not null"`                        // 设置为 100 主要是为了后面的 md5 加密
	NickName string     `gorm:"type:varchar(20)"`                                  // 允许为空
	Birthday *time.Time `gorm:"type:datetime"`
	Gender   string     `gorm:"column:gender;default:male;type:varchar(6) comment 'female 表示女，male 表示男'"`
	Role     int        `gorm:"column:role;default:1;type:int comment '1 表示普通用户，2 表示管理员'"`
}

同目录下的 main/main.go 的作用是用来连接数据库并调用 gorm 的模型进行建表

注意这里需要提前建库，库的语言选择：utf8mb4_general_ci

main.go

package main

import (
	"log"
	"os"
	"time"

	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
	"gorm.io/gorm/schema"

	"mxshop_srvs/user_srv/model"
)

func main() {
	dsn := "root:你的密码@tcp(你的ip:你的端口)/你的库名?charset=utf8mb4&parseTime=True&loc=Local"

	// 添加日志信息
	newLogger := logger.New(
		log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer
		logger.Config{
			SlowThreshold:             time.Second, // Slow SQL threshold
			LogLevel:                  logger.Info, // Log level
			IgnoreRecordNotFoundError: true,        // Ignore ErrRecordNotFound error for logger
			ParameterizedQueries:      true,        // Don't include params in the SQL log
			Colorful:                  true,        // Disable color,true is colorful, false to black and white
		},
	)

	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
		// 阻止向创建的数据库表后添加复数
		NamingStrategy: schema.NamingStrategy{
			SingularTable: true,
		},
		// 将日添加到配置中
		Logger: newLogger,
	})
	if err != nil {
		panic(err)
	}

	// 建表，此处导入的是之前创建的 model
	_ = db.AutoMigrate(&model.User{})
}

这个 main 文件顺利执行之后，数据库中的表就建好了，此处应该是创建好了一个 user 表

md5 加密

密码的存储需要使用 md5 加密后再进行存储，至于为什么要这么做不再赘述，这里只介绍流程：

func genMd5(code string) string {
	Md5 := md5.New()
	_, _ = io.WriteString(Md5, code)
	return hex.EncodeToString(Md5.Sum(nil))
}

func main() {
	fmt.Println(genMd5("123456"))
}

但是注意，这种 常规的 md5 加密模式对于简单的数字组合已经基本完成暴力解密了，所以当用户输入简单密码，例如：123456 这种时，已经完全可以被拦截到密码原文了，故而产生了进一步的 MD5 加密算法，MD5 盐值加密。

MD5 盐值加密也就是 将密码原文中添加一串随机数，再进行 MD5 加密

这里我们调用开源项目：go-password-encoder 进行盐值加密：

其中涉及到了向数据库中添加的密码问题，其策略是将加密方式、盐值、md5密码全部存储进数据库，再从数据库中取出来进行解析

package main

import (
	"crypto/md5"
	"crypto/sha512"
	"encoding/hex"
	"fmt"
	"github.com/anaskhan96/go-password-encoder"
	"io"
	"strings"
)

func genMd5(code string) string {
	Md5 := md5.New()
	_, _ = io.WriteString(Md5, code)
	return hex.EncodeToString(Md5.Sum(nil))
}

func main() {
	fmt.Println(genMd5("123456"))
	options := &password.Options{16, 100, 32, sha512.New}
	salt, encodedPwd := password.Encode("generic password", options)
	// 采取将 加密算法、盐值、加密后的密码 保存到数据库中
	newPassword := fmt.Sprintf("%s$%s$%s", "pbkdf2-sha512", salt, encodedPwd)
	passwordInfo := strings.Split(newPassword, "$")
	fmt.Println(passwordInfo)
	check := password.Verify("generic password", passwordInfo[1], passwordInfo[2], options)
	fmt.Println(check)
}

Proto

在提前建立好的 proto 目录下 创建对应的user.proto 文件

proto

user.proto

user.pb.go

user_grpc.pb.go

编写 .proto 文件：

syntax = "proto3";
import "google/protobuf/empty.proto";
option go_package = ".;proto";

service User{
  rpc GetUserList(PageInfo) returns (UserListResponse);   // 获取用户列表
  rpc GetUserByMobile(MobileRequest) returns (UserInfoResponse);    // 通过手机号获取用户信息
  rpc GetUserById(IdRequest) returns (UserInfoResponse);  // 通过id获取用户信息
  rpc CreateUser(CreateUserInfo) returns (UserInfoResponse);  // 创建用户
  rpc UpdateUser(UpdateUserInfo) returns (google.protobuf.Empty);   // 更新用户，此处返回空，要引入基础包中的 google.protobuf.empty
  rpc CheckPassWord(PassWordCheckInfo) returns (CheckResponse);   // 校验密码（通用校验）
}

message PassWordCheckInfo {
  string password = 1;
  string encryptedPassword = 2;
}

message CheckResponse {
  bool success = 1;
}

message PageInfo {
  uint32 pn = 1;
  uint32 pSize = 2;
}

message IdRequest {
  int32 id = 1;
}

message MobileRequest {
  string mobile = 1;
}

message CreateUserInfo {
  string nickname = 1;
  string password = 2;
  string mobile = 3;
}

message UpdateUserInfo {
  int32 id = 1;
  string nickName = 2;
  string gender = 3;
  uint64 birthDay = 4;
}

message UserInfoResponse {
  int32 id = 1;
  string password = 2;
  string mobile = 3;
  string nickName = 4;
  uint64 birthDay = 5;
  string gender = 6;
  int32 role = 7;
}

// 用户列表
message UserListResponse {
  int32 total = 1;
  repeated UserInfoResponse data = 2;
}

并调用对应的命令生成对应的 go 语言源码

我们在生成的 xxx_grpc.pb.go 的 xxxServer 中可以找到我们需要实现的接口进行实现

接口实现

接口的实现在 handler 目录下新建 .go 文件进行实现：

handler

user.go

注意这里先定义一下 gorm 的初始化工作：

在 global 目录中定义 init() 方法，该方法会自动被调用

global

global.go

global.go

package global

import (
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
	"gorm.io/gorm/schema"
	"log"
	"os"
	"time"
)

var (
	DB *gorm.DB
)

/*
*
注意：名称被定义为 init() 的韩式会在 main() 之前被调用
*/
func init() {
	dsn := "root:VBwH9eW*urHb@tcp(192.168.202.140:3306)/mxshop_user_srv?charset=utf8mb4&parseTime=True&loc=Local"

	// 添加日志信息
	newLogger := logger.New(
		log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer
		logger.Config{
			SlowThreshold:             time.Second, // Slow SQL threshold
			LogLevel:                  logger.Info, // Log level
			IgnoreRecordNotFoundError: true,        // Ignore ErrRecordNotFound error for logger
			ParameterizedQueries:      true,        // Don't include params in the SQL log
			Colorful:                  true,        // Disable color,true is colorful, false to black and white
		},
	)

	var err error
	DB, err = gorm.Open(mysql.Open(dsn), &gorm.Config{
		// 阻止向创建的数据库表后添加复数
		NamingStrategy: schema.NamingStrategy{
			SingularTable: true,
		},
		// 将日添加到配置中
		Logger: newLogger,
	})
	if err != nil {
		panic(err)
	}
}

GetUserList 接口

之后在 user.go 中实现接口：

package handler

import (
	"context"

	"gorm.io/gorm"

	"mxshop_srvs/user_srv/global"
	"mxshop_srvs/user_srv/model"
	"mxshop_srvs/user_srv/proto"
)

type UserServer struct{}

/*
* 优雅的分页方法
 */
func Paginate(page, pageSize int) func(db *gorm.DB) *gorm.DB {
	return func(db *gorm.DB) *gorm.DB {
		if page == 0 {
			page = 1
		}

		switch {
		case pageSize > 100:
			pageSize = 100
		case pageSize <= 0:
			pageSize = 10
		}
		
		offset := (page - 1) * pageSize
		return db.Offset(offset).Limit(pageSize)
	}
}

/**
* 转换 model 为 proto 的 UserInfoResponse
 */
func ModelToResponse(user model.User) proto.UserInfoResponse {
	userInfoRsp := proto.UserInfoResponse{
		Id:		user.ID,
		Password: user.Password,
		NickName: user.NickName,
		Gender: user.Gender,
		Role: int32(user.Role),
	}
	if user.Birthday != nil {
		userInfoRsp.BirthDay = uint64(user.Birthday.Unix())
	}
	return userInfoRsp
}

func (s *UserServer) GetUserList(ctx context.Context, req *proto.PageInfo) (*proto.UserListResponse, error) {
	var users []model.User
	result := global.DB.Find(&users) // result 只是查询的结果（是否出错等），不是最后得到的查询结果集
	if result.Error != nil {
		return nil, result.Error
	}

	rsp := &proto.UserListResponse{}
	rsp.Total = int32(result.RowsAffected) // 获取长度

	global.DB.Scopes(Paginate(int(req.Pn), int(req.PSize))).Find(&users)
	
	for _, user := range users {
		userInfoResponse := ModelToResponse(user)
		rsp.Data = append(rsp.Data, &userInfoResponse)
	}

	return rsp, nil
}

GetUserByxxx 接口

开发流程：

1. 在自动生成的xxx_grpc.pb.go 中找到需要实现的接口：

   GetUserByMobile(context.Context, *MobileRequest) (*UserInfoResponse, error)
   

   这里就是需要实现的接口

   我们在 handler 目录中 对应的 service 文件中定义新的方法：

   type UserServer struct{}
   
   
   func (s *UserServer) GetUserByMobile(ctx context.Context, req *proto.MobileRequest) (*proto.UserInfoResponse, error) {
   	
   }
   
   

   之后向其中添加对应的逻辑：

2. 对于 getUserByMobile 涉及到的问题：

   包括：查询出错、未查到信息、错误码等情况

   /*
   *
   通过手机号查询用户
   */
   func (s *UserServer) GetUserByMobile(ctx context.Context, req *proto.MobileRequest) (*proto.UserInfoResponse, error) {
   	// 用来存储取出来的 user
   	var user model.User
   	result := global.DB.Where(&model.User{Mobile: req.Mobile}).First(&user) // 查询一个，将结果录入
   	if result.RowsAffected == 0 {                                           // 若影响行数为 0 ，即没有查到对应的数据
   		return nil, status.Error(codes.NotFound, "用户不存在")
   	}
   	if result.Error != nil { // 若查询出现错误
   		return nil, result.Error
   	}
   
   	userInfoRsp := ModelToResponse(user)
   	return &userInfoRsp, nil // 走到这里的都成功了，叫做成功
   }
   

3. 实现 getUserById 方法：

   /**
   * 通过 id 查询用户
    */
   func (s *UserServer) GetUserById(ctx context.Context, req *proto.IdRequest) (*proto.UserInfoResponse, error) {
   	var user model.User
   	result := global.DB.First(&user, req.Id)
   	if result.RowsAffected == 0 {
   		return nil, status.Errorf(codes.NotFound, "用户不存在")
   	}
   
   	if result.Error != nil {
   		return nil, result.Error
   	}
   
   	userInfoRsp := ModelToResponse(user)
   	return &userInfoRsp, nil
   }
   

CreateUser 接口

/**
* 创建用户
 */
func (s *UserServer) CreateUser(ctx context.Context, req *proto.CreateUserInfo) (*proto.UserInfoResponse, error) {
	// 查询用户是否在库中已存在
	var user model.User
	result := global.DB.Where(&model.User{Mobile: req.Mobile}).First(&user)
	if result.RowsAffected == 1 { // 若准备新增的用户已存在
		return nil, status.Errorf(codes.AlreadyExists, "用户已存在")
	}
	user.Mobile = req.Mobile
	user.NickName = req.Nickname

	// 密码加密
	// 引入两个包:
	/**
	* go get github.com/anaskhan96/go-password-encoder	// 这个是外部包，必须引入
	* "crypto/sha1"		这个包是内部包，可能不需要引入
	 */
	options := &password.Options{16, 100, 32, sha1.New}
	salt, encodedPwd := password.Encode(req.Password, options)
	newPassword := fmt.Sprintf("$pdkdf2-sha512$%s$%s", salt, encodedPwd)
	user.Password = newPassword

	result = global.DB.Create(&user)
	if result.Error != nil {
		return nil, status.Errorf(codes.Internal, result.Error.Error())
	}

	userInfoRsp := ModelToResponse(user)
	return &userInfoRsp, nil
}

UpdateUser 接口

/**
* 更新用户
 */

func (s *UserServer) UpdateUser(ctx context.Context, req *proto.UpdateUserInfo) (*empty.Empty, error) {
	var user model.User
	result := global.DB.First(&user, req.Id)
	if result.RowsAffected == 0 {
		return nil, status.Errorf(codes.NotFound, "用户不存在")
	}
	// 将生日转换为时间，请求传入的是 uint64，这里要先转为int64，再转为 Time，才能存储到数据库中
	birthday := time.Unix(int64(req.BirthDay), 0)
	user.NickName = req.NickName
	user.Birthday = &birthday
	user.Gender = req.Gender

	result = global.DB.Save(user)
	if result.Error != nil {
		return nil, status.Errorf(codes.Internal, result.Error.Error()) // 传出错误
	}
	return &empty.Empty{}, nil
}

检查密码接口

/**
 * 检查密码
 */
func (s *UserServer) CheckPassWord(ctx context.Context, req *proto.PassWordCheckInfo) (*proto.CheckResponse, error) {
	options := &password.Options{16, 100, 32, sha1.New}
	passwordInfo := strings.Split(req.EncryptedPassword, "$")
	check := password.Verify(req.Password, passwordInfo[2], passwordInfo[3], options)
	return &proto.CheckResponse{Success: check}, nil
}

服务启动类配置

main.go：

package main

import (
	"flag"
	"fmt"
	"net"

	"google.golang.org/grpc"

	"mxshop_srvs/user_srv/handler"
	"mxshop_srvs/user_srv/proto"
)

func main() {
	// 由于ip和端口号有可能需要用户输入，所以这里摘出来
	// flag 包是一个命令行工具包，允许从命令行中设置参数
	IP := flag.String("ip", "0.0.0.0", "ip地址")
	Port := flag.Int("port", 50051, "端口号")
	flag.Parse()
	fmt.Println("ip: ", *IP)
	fmt.Println("port: ", *Port)

	// 创建新服务器
	server := grpc.NewServer()
	// 注册自己的已实现的方法进来
	proto.RegisterUserServer(server, &handler.UserServer{})

	lis, err := net.Listen("tcp", fmt.Sprintf("%s:%d", *IP, *Port))
	if err != nil {
		panic("failed to listen" + err.Error())
	}
	// 将自己的服务绑定端口
	err = server.Serve(lis)
	if err != nil {
		panic("fail to start grpc" + err.Error())
	}
}

此时我们直接运行 main.go 就会以 0.0.0.0:50051打开服务，但是我们配置了 命令行启动服务的功能，所以我们可以先打包这个项目，再使用命令行进行启动：

cd .\user_srv\
go build main.go

此时会打包出一个 main.exe 文件，此时：

start main.exe

就可以以默认形式启动刚刚的程序

再cmd中调用

main.exe -h

可以查看命令帮助，此处会生成：

Usage of main.exe:
  -ip string
        ip地址 (default "0.0.0.0")
  -port int
        端口号 (default 50051)

之后再进行调用：

main.exe -port 50053