目录
本文章讲解使用go-zero生成一个微服务的过程。其中的一些命令或者名不太熟悉的话，可以参考go-zero官网。
项目名字叫zero。创建zero目录，并在该目录下创建user目录。
1. 生成 user api 服务
在user目录下添加api目录，在api目录添加如下的api文件。
syntax = "v1"
type LoginReq {
Mobile string `json:"mobile"`
Password string `json:"password"`
}
type LoginResponse {
UserId int64 `"json:"userId"`
Token string `json:"token"`
}
@server (
prefix: v1
)
service user {
@handler login
post /user/login (LoginReq) returns (LoginResponse)
}在user/api下执行
goctl go api --api ./user.api --dir .执行生成后，api目录结构体如下
.
├── etc
│ └── user.yaml
├── internal
│ ├── config
│ │ └── config.go
│ ├── handler
│ │ ├── loginhandler.go
│ │ └── routes.go
│ ├── logic
│ │ └── loginlogic.go
│ ├── svc
│ │ └── servicecontext.go
│ └── types
│ └── types.go
├── user.api
└── user.go2. 生成 user rpc 服务
在user目录下创建rpc目录。在rpc目录下添加如下的proto文件。
syntax="proto3";
package user;
option go_package="./user";
//用户登录
message LoginRequest{
string mobile=1;
string Password=2;
}
message LoginResponse{
int64 Id=1;
}
service User{
rpc Login(LoginRequest)returns(LoginResponse);
}在user/rpc下执行
goctl rpc protoc ./user.proto --go_out=. --go-grpc_out=. --zrpc_out=.执行生成后，rpc目录结构如下
.
├── etc
│ └── user.yaml
├── internal
│ ├── code
│ │ └── code.go
│ ├── config
│ │ └── config.go
│ ├── db
│ │ └── mysql.go
│ ├── logic
│ │ └── loginlogic.go
│ ├── server
│ │ └── userserver.go
│ └── svc
│ └── servicecontext.go
├── user
│ ├── user_grpc.pb.go
│ └── user.pb.go
├── userclient
│ └── user.go
├── user.go
└── user.proto3. 生成 user model 模型
在user目录添加model目录，在model中添加如下的user.sql文件。
CREATE TABLE `user` (
`id` bigint unsigned NOT NULL AUTO_INCREMENT,
`name` varchar(255) NOT NULL DEFAULT '' COMMENT '用户姓名',
`mobile` varchar(255) NOT NULL DEFAULT '' COMMENT '用户电话',
`password` varchar(255) NOT NULL DEFAULT '' COMMENT '用户密码',
`create_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP,
`update_time` timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
PRIMARY KEY (`id`),
KEY `password` (`password`) ,
UNIQUE KEY `idx_mobile_unique` (`mobile`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;在model目录中执行
goctl model mysql ddl --src user.sql --dir . -c-c表示使用缓存。
执行生成后，model目录结构体如下
.
├── usermodel_gen.go
├── usermodel.go
├── user.sql
└── vars.go在usermodel_gen.go文件中，生成了一些基础的查询语句。
- 注意到user表中有3个key。主键和唯一键是可以确定一行数据的，而KEY `password`是普通的键，所以生成了通过id，通过mobile查找数据的语句。没有生成通过password查找的语句。
- 而且要注意到，这里是使用了缓存了，一般是使用redis。
//usermodel_gen.go
var (
..................
cacheUserIdPrefix = "cache:user:id:"
cacheUserMobilePrefix = "cache:user:mobile:"
)
type (
userModel interface {
Insert(ctx context.Context, data *User) (sql.Result, error)
FindOne(ctx context.Context, id uint64) (*User, error)
FindOneByMobile(ctx context.Context, mobile string) (*User, error)
Update(ctx context.Context, data *User) error
Delete(ctx context.Context, id uint64) error
}
defaultUserModel struct {
sqlc.CachedConn
table string
}
User struct {
Id uint64 `db:"id"`
Name string `db:"name"` // 用户姓名
Mobile string `db:"mobile"` // 用户电话
Password string `db:"password"` // 用户密码
CreateTime time.Time `db:"create_time"`
UpdateTime time.Time `db:"update_time"`
}
)4. 编写 user rpc 服务
1 修改配置文件 user.yaml
- 因为需要使用数据库MySql，所以我们需要配置数据库的参数,所以需要在user.yaml中填写数据库相关的参数。
- 而因为rpc是需要用到Etcd（用于服务注册发现等），所以还需要添加Etcd的配置。
- 在model中是使用了缓存的，所以也需要添加缓存的配置
Name: user.rpc
ListenOn: 0.0.0.0:8080
#Etcd部分和Mysql部分是新添加的
Etcd:
Hosts:
- 127.0.0.1:2379
Key: user.rpc
Mysql:
datasource: "root:wook1847@tcp(127.0.0.1:3306)/zero?charset=utf8mb4&parseTime=True&loc=Local"
CacheRedis:
- Host: 127.0.0.1:5678
Type: node
Pass: 1234562 添加 user model 依赖
- 添加
Mysql服务配置的实例化
在生成的config目录中有config.go文件，该文件中是用于解析配置文件的结构体。而这里我们添加了MySql配置，所以需要添加相关结构体来进行解析。而rest.RestConf中就带有etcd的(看源码），所以不用写etcd的。
type Config struct {
zrpc.RpcServerConf
MysqlConfig Mysql `json:"mysql"` //添加mysql的配置
CacheRedis cache.CacheConf
}
type Mysql struct {
Datasource string
}- 注册服务上下文
user model的依赖
在生成是svc目录中的 servicecontext.go文件，后续我们就是使用该文件中的ServiceContext。而要想可以使用mysql，那就需要在其添加该依赖。
package svc
import (
"mall/user/model"
"mall/user/rpc/internal/config"
"github.com/zeromicro/go-zero/core/stores/sqlx"
)
type ServiceContext struct {
Config config.Config
UserModel model.UserModel //添加数据库的依赖
}
func NewServiceContext(c config.Config) *ServiceContext {
conn := sqlx.NewMysql(c.MysqlConfig.Datasource)
return &ServiceContext{
Config: c,
UserModel: model.NewUserModel(conn, c.CacheRedis),
}
}3 添加用户登录逻辑 Login
接着看生成的logic目录中的loginlogic.go文件。这里就是我们要写的业务逻辑地方。logic目录中的文件是我们主要写代码的地方。在Login方法中添加业务逻辑。
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) {
// todo: add your logic here and delete this line
res, err := l.svcCtx.UserModel.FindOneByMobile(l.ctx, in.Mobile)
if err != nil {
if err == model.ErrNotFound {
return &user.LoginResponse{}, nil
}
return nil, err
}
if res.Password!=in.Password{
return nil,fmt.Errorf("password id wrong")
}
return &user.LoginResponse{Id: int64(res.Id)}, nil
}5. 编写 user api 服务
其过程和编写user rpc服务是类似的。
1 修改配置文件user.yaml
因为我们在api中需要使用rpc，所以我们就需要用到etcd，所以就需要etcd的配置。
Name: user
Host: 0.0.0.0
Port: 8888
#添加user rpc的etcd配置
UserRpc:
Etcd:
Hosts:
- 127.0.0.1:2379
Key: user.rpc
#要是还需要其他服务的rpc，那就需要添加的
# PayRpc:
# Etcd:
# Hosts:
# - 127.0.0.1:2379
# Key: pay.rpc2 添加 user rpc 依赖
- 添加
user rpc服务配置的实例化
在user.yaml中添加了user rpc的etcd配置后，那就需要再config.go文件中添加对应的结构体来解析配置。
而前面不是说了，etcd的结构体是rest.RestConf就带有的，不用填写了吗？
这不是这个意思的。这个是对应user rpc的etcd配置的。要是在api中还需要用其他服务，比如支付服务，而支付服务又是一个微服务，那就又要添加pay rpc的etcd配置的。
type Config struct {
rest.RestConf
UserRpc zrpc.RpcClientConf
// PayRpc zrpc.RpcClientConf 要是需要该服务的话，就需要添加
}- 添加
user rpc服务配置的实例化
type ServiceContext struct {
Config config.Config
UserRpc userclient.User //添加user rpc使用
}
func NewServiceContext(c config.Config) *ServiceContext {
return &ServiceContext{
Config: c,
UserRpc: userclient.NewUser(zrpc.MustNewClient(c.UserRpc)),
}
}3 添加用户登录逻辑 Login
在生成的logic目录中的loginlogic.文件。这里就是我们要写的业务逻辑。
type LoginLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewLoginLogic(ctx context.Context, svcCtx *svc.ServiceContext) *LoginLogic {
return &LoginLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
//在该方法中添加我们的业务逻辑
func (l *LoginLogic) Login(req *types.LoginReq) (resp *types.LoginResponse, err error) {
// todo: add your logic here and delete this line
res, err := l.svcCtx.UserRpc.Login(l.ctx, &userclient.LoginRequest{
Mobile: req.Mobile,
Password: req.Password,
})
if err != nil {
return nil, err
}
if res != nil && res.Id == 0 {
return nil, fmt.Errorf("has not this user")
}
//成功后，生成token
token := "1234534345"
return &types.LoginResponse{UserId: res.Id, Token: token}, nil
}6. 启动服务
因为api服务是依赖rpc服务，所以先启动rpc服务，再启动api服务。
启动rpc服务
在user/api中执行
go run user.go启动api服务
在user/rpc中执行
go run user.go登录成功，查看缓存
登录成功后，Redis中会缓存该用户的数据。因为生成model时候，是使用了缓存的。还记得在model环节生成的usermodel_gen.go文件。这两个就是key，拼接上对应的id或者mobile即可。
//usermodel_gen.go
var (
..................
cacheUserIdPrefix = "cache:user:id:"
cacheUserMobilePrefix = "cache:user:mobile:"
)