项目构建

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

mxshop_srvs

user_srv

global 公共内容

handler 服务

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

proto 暴露接口

main.go 用来启动程序

数据模型创建

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

model

user.go

main

main.go

user.go：

package modelimport ("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.DeletedAtIsDeleted bool
}type User struct {BaseModelMobile   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 mainimport ("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 writerlogger.Config{SlowThreshold:             time.Second, // Slow SQL thresholdLogLevel:                  logger.Info, // Log levelIgnoreRecordNotFoundError: true,        // Ignore ErrRecordNotFound error for loggerParameterizedQueries:      true,        // Don't include params in the SQL logColorful:                  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 mainimport ("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.emptyrpc 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 globalimport ("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 writerlogger.Config{SlowThreshold:             time.Second, // Slow SQL thresholdLogLevel:                  logger.Info, // Log levelIgnoreRecordNotFoundError: true,        // Ignore ErrRecordNotFound error for loggerParameterizedQueries:      true,        // Don't include params in the SQL logColorful:                  true,        // Disable color,true is colorful, false to black and white},)var err errorDB, err = gorm.Open(mysql.Open(dsn), &gorm.Config{// 阻止向创建的数据库表后添加复数NamingStrategy: schema.NamingStrategy{SingularTable: true,},// 将日添加到配置中Logger: newLogger,})if err != nil {panic(err)}
}

GetUserList 接口

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

package handlerimport ("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 = 100case pageSize <= 0:pageSize = 10}offset := (page - 1) * pageSizereturn 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.Userresult := 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) {// 用来存储取出来的 uservar user model.Userresult := 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.Userresult := 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.Userresult := global.DB.Where(&model.User{Mobile: req.Mobile}).First(&user)if result.RowsAffected == 1 { // 若准备新增的用户已存在return nil, status.Errorf(codes.AlreadyExists, "用户已存在")}user.Mobile = req.Mobileuser.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 = newPasswordresult = 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.Userresult := 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.NickNameuser.Birthday = &birthdayuser.Gender = req.Genderresult = 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 mainimport ("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 stringip地址 (default "0.0.0.0")-port int端口号 (default 50051)

之后再进行调用：

main.exe -port 50053