目录
1. 生成 user api 服务
2. 生成 user rpc 服务
3. 生成 user model 模型
4. 编写 user rpc 服务
1 修改配置文件 user.yaml
2 添加 user model 依赖
3 添加用户登录逻辑 Login
5. 编写 user api 服务
1 修改配置文件user.yaml
2 添加 user rpc 依赖
3 添加用户登录逻辑 Login
6. 启动服务
启动rpc服务
启动api服务
登录成功，查看缓存
本文章讲解使用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 loginpost /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) errorDelete(ctx context.Context, id uint64) error}defaultUserModel struct {sqlc.CachedConntable 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:2379Key: user.rpcMysql:datasource: "root:wook1847@tcp(127.0.0.1:3306)/zero?charset=utf8mb4&parseTime=True&loc=Local"
CacheRedis:
- Host: 127.0.0.1:5678Type: nodePass: 1234562 添加 user model 依赖
- 添加
Mysql服务配置的实例化
在生成的config目录中有config.go文件，该文件中是用于解析配置文件的结构体。而这里我们添加了MySql配置，所以需要添加相关结构体来进行解析。而rest.RestConf中就带有etcd的(看源码），所以不用写etcd的。
type Config struct {zrpc.RpcServerConfMysqlConfig Mysql `json:"mysql"` //添加mysql的配置CacheRedis cache.CacheConf
}type Mysql struct {Datasource string
}- 注册服务上下文
user model的依赖
在生成是svc目录中的 servicecontext.go文件，后续我们就是使用该文件中的ServiceContext。而要想可以使用mysql，那就需要在其添加该依赖。
package svcimport ("mall/user/model""mall/user/rpc/internal/config""github.com/zeromicro/go-zero/core/stores/sqlx"
)type ServiceContext struct {Config config.ConfigUserModel 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.ContextsvcCtx *svc.ServiceContextlogx.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 lineres, 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:2379Key: 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.RestConfUserRpc zrpc.RpcClientConf// PayRpc zrpc.RpcClientConf 要是需要该服务的话，就需要添加
}- 添加
user rpc服务配置的实例化
type ServiceContext struct {Config config.ConfigUserRpc 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.Loggerctx context.ContextsvcCtx *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 lineres, 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")}//成功后，生成tokentoken := "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:"
)
