go-zero 实战（2）

go-zero 实战（1）中，使用了go-zero 创建了order 和 user 两个微服务。而order作为grpc的客户端，user 作为grpc的服务端，打通了 order 到 user的调用。接下来，我们在user中，加入mysql组件。确保数据能够写到数据库。

引入MySQL

1. 启动mysql，创建数据库 zero-mall

可以使用 DBeaver 工具，连接mysql，并创建zero-mall数据库。
在这里插入图片描述
并且执行如下脚本创建表：

use zero_mall;create table `user`(id bigint(0) not null auto_increment,name varchar(255) character set utf8mb4 COLLATE utf8mb4_general_ci not null,gender varchar(255) character set utf8mb4 COLLATE utf8mb4_general_ci not null,PRIMARY key (id) using btree
);

2. 在 user/internal 目录下创建 model目录，并创建user.sql

创建 user.sql 文件，并将上面脚本放入 user.sql 文件中。然后，在当前目录下，执行：

goctl model mysql ddl -src user.sql -dir . -c

这步操作，会生成操作数据库相关的代码。由于生成的代码比较乱。我们在做数据库连接的时候，会摘取部分代码，按照自己的思路做数据库相关操作。

在当前目录下新建 user.go (user/internal/model/user.go)文件，把当前生成的 usermodel_gen.go 文件中的 User 结构体拿出来，放到user.go 文件中，并添加一个 TableName函数。然后，把生成的 usermodel.go、usermodel_gen.go、vars.go文件删除。最终的 user.go 代码如下：

package modeltype User struct {Id     int64  `db:"id"`Name   string `db:"name"`Gender string `db:"gender"`
}
// 返回表名
func (User) TableName() string {return "user"
}

当我们创建了model之后，就有User 实体，该实体映射数据库的User表。接下来的我们需要创建数据库的连接。

3. 在user下创建database目录

创建database目录，在该目录下创建sqlx.go文件，主要为了使用 go-zero的orm框架。当然，这个目录下也可以创建如 mongo、redis的连接。也可以使用不同的orm框架，如gorm等。

sqlx.go 文件

package databaseimport "github.com/zeromicro/go-zero/core/stores/sqlx"// we use go-zero sqlxtype DBConn struct {Conn sqlx.SqlConn
}func Connect(datasource string) *DBConn {return &DBConn{Conn: sqlx.NewMysql(datasource),}
}

4. 创建操作数据的接口，并提供实现

在 user/internal/ 下创建 repo 目录，并创建 user.go 文件

package repoimport ("context""user/internal/model"
)type UserRepo interface {Save(ctx context.Context, user *model.User) error
}

该代码提供了一个Save接口，用来保存 User。

在 user/internal/ 下创建 dao 目录，并创建 user.go 文件，提供接口的实现。

package daoimport ("context""fmt""user/database""user/internal/model"
)type UserDao struct {*database.DBConn
}func NewUserDao(conn *database.DBConn) *UserDao {return &UserDao{conn,}
}func (d *UserDao) Save(ctx context.Context, user *model.User) error {sql := fmt.Sprintf("insert into %s (name, gender) values(?, ?)", user.TableName())result, err := d.Conn.ExecCtx(ctx, sql, user.Name, user.Gender)if err != nil {return err}id, err := result.LastInsertId()if err != nil {return err}user.Id = idreturn nil}

5. 修改 user/internal/config目录下的 config.go文件

由于，我们需要连接 mysql 数据库。因此，我们需要从配置文件中读取 mysql 连接的配置。go-zero 提供了一种简便方式，可以自动读取配置。

首先，修改 user/etc/user.yaml中的配置，如下：

Name: user.rpc
ListenOn: 0.0.0.0:8080
Etcd:Hosts:- 127.0.0.1:2379Key: user.rpcMysql:Datasource: root:thinker@tcp(127.0.0.1:33306)/zero_mall?charset=utf8mb4&parseTime=True&loc=Asia%2FShanghai

Mysql 的配置是我自己手动添加的。

user/internal/config/config.go 文件如下：

package configimport "github.com/zeromicro/go-zero/zrpc"type Config struct {zrpc.RpcServerConfMysql MysqlConfig
}type MysqlConfig struct {DataSource string
}

该文件中添加了 MySqlConfig 结构体，并且在Config 结构体中添加了 Mysql 变量。这样 go-zero 可以自动读取到 user.yaml 中 Mysql连接配置。

6. 修改 user/rpc/user.proto 文件，并重新生成代码

user.proto 文件

option go_package = "./user";message IdRequest {string id = 1;
}message UserRequest {string id = 1;string name = 2;string gender = 3;
}message UserResponse {string id = 1;string name = 2;string gender = 3;
}service User {rpc getUser(IdRequest) returns(UserResponse);rpc save(UserRequest) returns(UserResponse);
}

该代码中，添加了 rpc save(UserRequest) returns(UserResponse); 接口。并使用如下命令重新生成代码：

goctl rpc protoc user.proto --go_out=./types --go-grpc_out=./types --zrpc_out=.

7. 修改userserver.go 和 getuserlogic.go 代码

将生成的 types/user 和 userclient/下的代码，覆盖之前生成的代码。并且把 internal/server/userserver.go 文件中的如下代码（新生成的代码）：

func (s *UserServer) Save(ctx context.Context, in *user.UserRequest) (*user.UserResponse, error) {l := logic.NewUserLogic(ctx, s.svcCtx)return l.SaveUser(in)
}

放到 user/internal/server/userserver.go（旧文件中）文件中。

修改 user/internal/logic/getuserlogic.go代码，为了命名规范，我将getuserlogic.go 该成了 userlogic.go。

package logicimport ("context""strconv""user/internal/model""user/internal/svc""user/types/user""github.com/zeromicro/go-zero/core/logx"
)type UserLogic struct {ctx    context.ContextsvcCtx *svc.ServiceContextlogx.Logger
}func NewUserLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserLogic {return &UserLogic{ctx:    ctx,svcCtx: svcCtx,Logger: logx.WithContext(ctx),}
}func (l *UserLogic) GetUser(in *user.IdRequest) (*user.UserResponse, error) {// todo: add your logic here and delete this linereturn &user.UserResponse{Id:     in.GetId(),Name:   "hello user name",Gender: "man",}, nil
}func (l *UserLogic) SaveUser(in *user.UserRequest) (*user.UserResponse, error) {data := &model.User{Name:   in.Name,Gender: in.Gender,}err := l.svcCtx.UserRepo.Save(context.Background(), data)if err != nil {return nil, err}return &user.UserResponse{Id:     strconv.FormatInt(data.Id, 10),Name:   data.Name,Gender: data.Gender,}, nil
}

userlogic 相当于业务组件，这里实现了用户保存到数据库的逻辑。

到此，在user服务中连接mysql数据库，并实现通过rpc接口调用将用户数据保存到 mysql 逻辑已经完成。

8. 调用 rpc 接口，测试 user 保存到数据库

1. 在mall 目录下执行如下命令，创建 userapi微服务（为了测试user rpc 保存到数据的功能）：

goctl api new userapi

2. 在 userapi 目录下，创建一个 go.mod 文件，文件内容如下：

module userapigo 1.22.2

3. 在 mall 目录下执行如下命令，将 userapi 加入workspace中

go work use userapi/
cd userapi/
go mod tidy

到此，生成的代码结构如下：
在这里插入图片描述

生成的包名稍微有点问题，建议直接手动修改一下。将user/api 改为 userapi。

4. 修改 userapi/etc/user-api.yaml 文件如下：

Name: userapi-api
Host: 0.0.0.0
Port: 8888
UserRpc:Etcd:Hosts:- 127.0.0.1:2379Key: user.rpc

该文件中增加了 UserRpc 配置，主要是为了调用rpc接口。

5. 修改 userapi/internal/config/config.go 文件

package configimport ("github.com/zeromicro/go-zero/rest""github.com/zeromicro/go-zero/zrpc"
)type Config struct {rest.RestConfUserRpc zrpc.RpcClientConf
}

增加了 UserRpc 变量，为了读取 user-api.yaml 中的配置。

6. 修改userapi/internal/handler/routers.go文件

在 userapi/internal/handler 目录下创建 register.go 文件和 userhandler.go文件

package handlerimport ("github.com/zeromicro/go-zero/rest/httpx""net/http""userapi/internal/logic""userapi/internal/types"
)func (u *UserHandler) register(w http.ResponseWriter, r *http.Request) {var req types.Requestif err := httpx.ParseJsonBody(r, &req); err != nil {httpx.ErrorCtx(r.Context(), w, err)return}l := logic.NewUserLogic(r.Context(), u.svcCtx)resp, err := l.Register(&req)if err != nil {httpx.ErrorCtx(r.Context(), w, err)} else {httpx.OkJsonCtx(r.Context(), w, resp)}
}

userhandler.go

package handlerimport ("userapi/internal/svc"
)type UserHandler struct {svcCtx *svc.ServiceContext
}func NewUserHandler(svcCtx *svc.ServiceContext) *UserHandler {return &UserHandler{svcCtx: svcCtx,}}

删除自动生成的代码 userapihandler.go 文件。

将生成的 userapi/internal/handler/routers.go 文件修改如下：

// Code generated by goctl. DO NOT EDIT.
package handlerimport ("net/http""userapi/internal/svc""github.com/zeromicro/go-zero/rest"
)func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {handler := NewUserHandler(serverCtx)server.AddRoutes([]rest.Route{{Method:  http.MethodPost,Path:    "/register",Handler: handler.register,},},)
}

7. 修改 userapi/internal/types.go 文件

// Code generated by goctl. DO NOT EDIT.
package typestype Request struct {Name string `json:"name"`Gender string `json:"gender"`
}type Response struct {Message string `json:"message"`Data any `json:"data"`
}

这里主要是为了处理 http请求过来的 json数据。

8. 为了使用 Rpc 服务，修改 userapi/internal/svc/servicecontext.go 文件

servicecontext.go 文件

package svcimport ("github.com/zeromicro/go-zero/zrpc""user/userclient""userapi/internal/config"
)type ServiceContext struct {Config  config.ConfigUserRpc userclient.User
}func NewServiceContext(c config.Config) *ServiceContext {return &ServiceContext{Config:  c,UserRpc: userclient.NewUser(zrpc.MustNewClient(c.UserRpc)),}
}

这里加入了 UserRpc 变量，为了远程调用User服务提供Save方法。

9.修改业务代码 userapi/internal/logic/userapilogic.go

package logicimport ("context""time""user/types/user""userapi/internal/svc""userapi/internal/types""github.com/zeromicro/go-zero/core/logx"
)type UserLogic struct {logx.Loggerctx    context.ContextsvcCtx *svc.ServiceContext
}func NewUserLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserLogic {return &UserLogic{Logger: logx.WithContext(ctx),ctx:    ctx,svcCtx: svcCtx,}
}func (l *UserLogic) Register(req *types.Request) (resp *types.Response, err error) {// todo: add your logic here and delete this linectx, cancelFunc := context.WithTimeout(context.Background(), 5*time.Second)defer cancelFunc()userResponse, err := l.svcCtx.UserRpc.Save(ctx, &user.UserRequest{Name:   req.Name,Gender: req.Gender,})if err != nil {return nil, err}return &types.Response{Message: "success",Data:    userResponse,}, nil
}

9 测试

启动 user 服务
启动 userapi 服务
用 postman测试，并查看数据库

测试成功。

10. 重构代码。

由于在 userapi中，用到user中的代码。并且之前的 order中也直接引用了user中的代码。这样增加了耦合性。我们可以把这部分公共的代码拿出来，这样以后。即使user服务发生变动，只要公共部分不变。那么userapi和order服务就不会受到影响。

1. 创建公共目录

mkdir rpc-common
cd rpc-common

2. 创建 go.mod 文件

在 mall/rpc-common下创建 go.mod文件

module rpc-commongo 1.22.2

3. 将 rpc-common 加入 workspacke

在 mall 目录下，执行命令

go work use rpc-common