目标

实现一个GRPC框架，可以通过grpc-ui来对接口进行访问。也可以使用client来直接调用服务端服务

准备（这边以Mac系统举例）

安装homebrew（如果没有安装的话）

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

安装PostgresSql（熟悉Mysql的也可以用mysql代替）

brew install postgresqlpsql --version 

安装protobuf 相关组件

brew install protobufbrew install protoc-gen-gobrew install protoc-gen-go-grpcprotoc --versionprotoc-gen-go --versionprotoc-gen-go-grpc --version

安装grpc-ui

go install github.com/fullstorydev/grpcui/cmd/grpcui@latest

第一步 定义接口（.proto文件）

初始化一个go工程，我这边命名为school-rpc
创建一个protobuf文件夹，定义一个student.proto文件,该文件后续会由编译脚本进行执行，用于生成pb.go 以及grpc_pb.go 文件

syntax = "proto3";option go_package = "./protobuf/student";
package school_rpc_service.student;message StudentListRequest{uint32 pageSize = 1;uint32 pageNo = 2;
}message CreateStudentRequest{string name = 1;uint32 age = 2;uint32 gender = 3;string  mobile = 4;string className = 5;uint32 grade =6;
}message UpdateStudentRequest{uint64  id = 1;string name = 2;uint32 age = 3;uint32 gender = 4;string  mobile = 5;string className = 6;uint32 grade =7;
}message StudentListResponse {string code = 1;string msg = 2;repeated Student studentList = 3;
}message CreateStudentResponse {string code = 1;string msg = 2;int64 id = 3;
}message UpdateStudentResponse {string code = 1;string msg = 2;}message Student {string id = 1;          // 学生 IDstring name = 2;        // 学生姓名uint32 age = 3;          // 学生年龄uint32 gender = 4;string  mobile = 5;string className = 6;uint32 grade =7;
}service StudentService {rpc studentList(StudentListRequest) returns (StudentListResponse){}rpc createStudent(CreateStudentRequest) returns (CreateStudentResponse){}rpc updateStudent(UpdateStudentRequest) returns (UpdateStudentResponse){}
}

第二步， 定义编脚本（compile.sh）

上一步中，我们已经定义好了.proto 文件，现在需要来处理一下编译的脚本
如果，在这一步中，如果我们没有安装protobuf 相关的组件，请参考准备阶段的流程，进行安装。
完成安装后，我们在项目的bin目录下，创建一个compile.sh 文件
compile.sh：

#!/bin/bashfunction exit_if() {extcode=$1msg=$2if [ $extcode -ne 0 ]thenif [ "msg$msg" != "msg" ]; thenecho $msg >&2fiexit $extcodefi
}echo $GOPATH;if [ ! -f $GOPATH/bin/protoc-gen-go ]
thenecho 'No plugin for golang installed, skip the go installation' >&2echo 'try go get github.com/golang/protobuf/protoc-gen-go' >&2
elseecho Compiling go interfaces...export GO_PATH=$GOPATHexport GOBIN=$GOPATH/binexport PATH=$PATH:$GOPATH/binprotoc -I ./ --go_out=./ --go-grpc_out=require_unimplemented_servers=false:. protobuf/*.protoexit_if $?echo Done
fi

第三步 编写MakeFile

来验证compile.sh 脚本是否能够成功编译成.go代码,以及生成执行文件

school-rpc:./bin/compile.shenv GO111MODULE=on go build $(LDFLAGS)
.PHONY: school-rpcclean:rm school-rpctest:go test -v ./...lint:golangci-lint run ./...

同步写一个main.go , main方法中，随便打印一行hello world 即可
此时的整个目录结构如下

Makefile ,main.go ,go.mod , compile.sh,student.proto 一共5个文件，结构还是比较清晰
然后，唤起一个终端，使用 "make" 命令

如上提示即代表成功，成功后的目录结构下多了school-rpc执行文件 和 student.pb.go & student_grpc.pb.go

第四步 初始化Sql相关

我们在工程的目录下，创建一个migration的目录，用于存放初始化sql

CREATE TABLE IF NOT EXISTS students (id BIGSERIAL PRIMARY KEY,name VARCHAR(100),age INT,gender INT,mobile VARCHAR(100),class_name VARCHAR(100),grade INT
);CREATE TABLE IF NOT EXISTS clazz (id BIGSERIAL PRIMARY KEY,name VARCHAR(100),grade INT
)

然后，我们期望在执行makefile的之后，能够根据命令参数，来执行具体的操作。因此我们需要在项目中增加一个cmd的目录，并在其中增加一个cli.go

// 具体执行migration的方法
func runMigrations(ctx *cli.Context) error {ctx.Context = opio.CancelOnInterrupt(ctx.Context)cfg := config.NewConfig(ctx)db, err := database.NewDB(ctx.Context, cfg.Database)if err != nil {return err}defer func(db *database.DB) {err := db.Close()if err != nil {}}(db)err = db.ExecuteSQLMigration(cfg.Migrations)if err != nil {return err}return nil
}
// 创建一个cli App实例，其中包含了执行migrations包下面的sql
func NewCli(GitCommit string, GitData string) *cli.App {flags := flags2.Flagsreturn &cli.App{Version:              params.VersionWithCommit(GitCommit, GitData), // 将git提交信息，和版本信息组合在一起生产版本信息Description:          "An exchange school services with rpc and rest api server",EnableBashCompletion: true,Commands: []*cli.Command{{Name:        "migrate",Flags:       flags,Description: "Run database migrations",Action:      runMigrations,},},}
}

然后，我们在db里面把该有的逻辑进行一下补充

func (db *DB) ExecuteSQLMigration(migrationsFolder string) error {err := filepath.Walk(migrationsFolder, func(path string, info os.FileInfo, err error) error {if err != nil {return errors.Wrap(err, fmt.Sprintf("Failed to process migration file: %s", path))}if info.IsDir() {return nil}fileContent, readErr := os.ReadFile(path)if readErr != nil {return errors.Wrap(readErr, fmt.Sprintf("Error reading SQL file: %s", path))}execErr := db.gorm.Exec(string(fileContent)).Errorif execErr != nil {return errors.Wrap(execErr, fmt.Sprintf("Error executing SQL script: %s", path))}return nil})return err
}

如此，我们就把通过命令行，执行初始化sql语句的逻辑给写好了
最后，我们把main.go 移动到/cmd 目录下，同时，添加命令行相关的代码，用于执行相关的命令行

func main() {log.SetDefault(log.NewLogger(log.NewTerminalHandlerWithLevel(os.Stderr, log.LevelInfo, true)))app := NewCli(GitCommit, GitData)// 这个方法的作用是否是增加一个信号中断处理器，用于通知给上下文ctx := opio.WithInterruptBlocker(context.Background())// 真正执行的是command.go Run方法if err := app.RunContext(ctx, os.Args); err != nil {log.Error("Application failed")os.Exit(1)}
}

并且将makefile也一并进行修改

school-rpc:./bin/compile.shenv GO111MODULE=on go build -v -o school-rpc $(LDFLAGS) ./cmdclean:rm school-rpctest:go test -v ./...lint:golangci-lint run ./...

第五步 通过flag将配置文件配置好之后，即可初始化数据库

const evnVarPrefix = "SCHOOL"func prefixEnvVars(name string) []string {return []string{evnVarPrefix + "_" + name}
}var (MigrationsFlag = &cli.StringFlag{Name:    "migrations-dir",Value:   "./migrations",Usage:   "path for database migrations",EnvVars: prefixEnvVars("MIGRATIONS_DIR"),}// RpcHostFlag RPC ServiceRpcHostFlag = &cli.StringFlag{Name:     "rpc-host",Usage:    "The port of the rpc",EnvVars:  prefixEnvVars("RPC_HOST"),Required: true,}// RpcPortFlagRpcPortFlag = &cli.IntFlag{Name:     "rpc-port",Usage:    "The port of the rpc",EnvVars:  prefixEnvVars("RPC_PORT"),Value:    8987,Required: true,}// MetricsHostFlag MetricsMetricsHostFlag = &cli.StringFlag{Name:     "metrics-host",Usage:    "The port of the metrics",EnvVars:  prefixEnvVars("METRICS_PORT"),Required: true,}MetricsPortFlag = &cli.IntFlag{Name:     "metrics-port",Usage:    "The port of the metrics",EnvVars:  prefixEnvVars("METRICS_PORT"),Value:    7214,Required: true,}// DbHostFlag DatabaseDbHostFlag = &cli.StringFlag{Name:     "master-db-host",Usage:    "The hostname of the database master",EnvVars:  prefixEnvVars("DB_HOST"),Required: true,}DbPortFlag = &cli.IntFlag{Name:     "master-db-port",Usage:    "The port of the master database",EnvVars:  prefixEnvVars("DB_PORT"),Required: true,}DbUserFlag = &cli.StringFlag{Name:     "master-db-user",Usage:    "The user of the master database",EnvVars:  prefixEnvVars("DB_USER"),Required: true,}DbPasswordFlag = &cli.StringFlag{Name:     "master-db-password",Usage:    "The password of the master database",EnvVars:  prefixEnvVars("DB_PASSWORD"),Required: true,}DbNameFlag = &cli.StringFlag{Name:     "master-db-name",Usage:    "The name of the master database",EnvVars:  prefixEnvVars("DB_NAME"),Required: true,}
)var requireFlags = []cli.Flag{MigrationsFlag,RpcHostFlag,RpcPortFlag,MetricsHostFlag,MetricsPortFlag,DbHostFlag,DbPortFlag,DbUserFlag,DbPasswordFlag,DbNameFlag,
}var optionalFlags = []cli.Flag{}func init() {Flags = append(requireFlags, optionalFlags...)
}var Flags []cli.Flag

这一步的核心功能是从.env 文件中读取数据，然后生成配置信息，供业务层进行使用
以下是.env 中的信息

export SCHOOL_RPC_PORT=8980
export SCHOOL_RPC_HOST="127.0.0.1"
export SCHOOL_METRICS_PORT=8990
export SCHOOL_METRICS_HOST="127.0.0.1"export SCHOOL_DB_HOST="127.0.0.1"
export SCHOOL_DB_PORT=5432
export SCHOOL_DB_USER="school"
export SCHOOL_DB_PASSWORD="1234"
export SCHOOL_DB_NAME="school"

注意我们一定需要source .env 一下，要不然执行脚本读取不到.env 文件里面的信息

第六步 初始化数据库

到这一步的时候，我们的工程结构是这样的

使用 make clean && make 命令，重新生成执行文件
执行./school-rpc 会有命令选项出现

我们可以执行 ./school-rpc migrate 执行初始化sql，如果没有报错，我们在数据库里面能查到新建的表结构代表创建已经成功了

第七步 实现相关的接口

第一步 在工程下，我们创建一个services 目录，services下分别建立一个
rpcServer.go 和 studentHandle.go

rpcServer.go 主要是用来定义rpc服务端，监听指定的端口号

核心方法为三个

创建 rpcServer实例

根据上下文传递的配置和db，返回rpcServer实例的指针

start方法

创建一个协程，使用配置项所设置的地址和端口号，来呼起一个grpc服务

stop方法

这里只是单纯修改一下rpcServer的状态（可忽略）

const MaxRecvMessageSize = 1024 * 1024 * 300type RpcServerConfig struct {GrpcHostname stringGrpcPort     int
}type RpcServer struct {*RpcServerConfigdb *database.DBwallet.UnimplementedWalletServiceServerstopped atomic.Bool
}func (s *RpcServer) Stop(ctx context.Context) error {s.stopped.Store(true)return nil
}func (s *RpcServer) Stopped() bool {//TODO implement mepanic("implement me")
}func NewRpcServer(db *database.DB, config *RpcServerConfig) (*RpcServer, error) {return &RpcServer{RpcServerConfig: config,db:              db,}, nil
}func (s *RpcServer) Start(ctx context.Context) error {go func(s *RpcServer) {addr := fmt.Sprintf("%s:%d", s.GrpcHostname, s.GrpcPort)fmt.Println("start rpc server", "addr", addr)listener, err := net.Listen("tcp", addr)if err != nil {fmt.Println("Could not start rpc server", "err", err)}opt := grpc.MaxRecvMsgSize(MaxRecvMessageSize)//创建一个新的 gRPC 服务器实例 gs，并注册反射服务（允许客户端通过反射查询服务信息）。gs := grpc.NewServer(opt, grpc.ChainUnaryInterceptor(nil))reflection.Register(gs)//注册服务wallet.RegisterWalletServiceServer(gs, s)// 启动grpc服务fmt.Println("start rpc server", "port", s.GrpcPort, "address", listener.Addr())if err := gs.Serve(listener); err != nil {fmt.Println("start rpc server", "err", err)}}(s)return nil
}

studentHandle.go

这部分核心主要就是实现对应的在proto文件中的接口方法的声明

func (s *RpcServer) StudentList(ctx context.Context, request *student.StudentListRequest) (*student.StudentListResponse, error) {schoolDB := s.GetRpcSchoolDB()studentList, err := schoolDB.FindStudentList(request.GetPageSize(), request.GetPageNo())studentPointers := make([]*student.Student, len(studentList))for i := range studentList {studentPoint := &student.Student{Name:      studentList[i].Name,Age:       studentList[i].Age,Gender:    studentList[i].Gender,Mobile:    studentList[i].Mobile,ClassName: studentList[i].ClassName,Grade:     studentList[i].Grade,}studentPointers[i] = studentPoint}if err != nil {return nil, err}return &student.StudentListResponse{Code:        strconv.Itoa(200),Msg:         "get Student List SUCCESS",StudentList: studentPointers,}, nil
}func (s *RpcServer) CreateStudent(ctx context.Context, request *student.CreateStudentRequest) (*student.CreateStudentResponse, error) {schoolDB := s.GetRpcSchoolDB()err := schoolDB.CreateStudent(&database.Student{Name:      request.Name,Age:       request.Age,Gender:    request.Gender,Mobile:    request.Mobile,ClassName: request.ClassName,Grade:     request.Grade,})if err != nil {return &student.CreateStudentResponse{Code: strconv.Itoa(500),Msg:  "Create Student Fail",}, err}return &student.CreateStudentResponse{Code: strconv.Itoa(200),Msg:  "Create Student SUCCESS",}, nil
}func (s *RpcServer) UpdateStudent(ctx context.Context, request *student.UpdateStudentRequest) (*student.UpdateStudentResponse, error) {schoolDB := s.GetRpcSchoolDB()err := schoolDB.UpdateStudent(&database.Student{Id:        request.Id,Name:      request.Name,Age:       request.Age,Gender:    request.Gender,Mobile:    request.Mobile,ClassName: request.ClassName,Grade:     request.Grade,})if err != nil {return &student.UpdateStudentResponse{Code: strconv.Itoa(500),Msg:  "Create Student Fail",}, err}return &student.UpdateStudentResponse{Code: strconv.Itoa(200),Msg:  "Create Student SUCCESS",}, nil}

至于DB中的方法，主要就是gorm中的crud方法，限于篇幅，这里不作赘述，有兴趣可以看源码链接

cli.go

命令行 文件中需要增加对 启动服务端程序的实现，以及命令中增加指定的参数选择

func runRpc(ctx *cli.Context, causeFunc context.CancelCauseFunc) (cliapp.Lifecycle, error) {fmt.Println("running grpc server...")cfg := config.NewConfig(ctx)grpcServerCfg := &services.RpcServerConfig{GrpcHost: cfg.RpcServer.Host,GrpcPort: strconv.Itoa(cfg.RpcServer.Port),}db, err := database.NewDB(ctx.Context, cfg.Database)if err != nil {log.Error("failed to connect to database", "err", err)return nil, err}return services.NewRpcServer(grpcServerCfg, db)
}func NewCli(GitCommit string, GitData string) *cli.App {flags := flags2.Flagsreturn &cli.App{Version:              params.VersionWithCommit(GitCommit, GitData), // 将git提交信息，和版本信息组合在一起生产版本信息Description:          "An exchange school services with rpc and rest api server",EnableBashCompletion: true,Commands: []*cli.Command{{Name:        "rpc",Flags:       flags,Description: "Run rpc services",Action:      cliapp.LifecycleCmd(runRpc),},{Name:        "migrate",Flags:       flags,Description: "Run database migrations",Action:      runMigrations,},},}
}

从上面的代码中可以看到，两个命令行，一个是run rpc services 的命令，另外一个是执行初始化sql的命令。至此，所有的代码已经ready，可以看看效果了。

第八步，试试RPC 服务端的具体效果

第一步 重新执行一下 make clean && make 。生成最新的执行文件

可以看到项目的根目录中包含了 school-rpc 执行文件

第二步 再次执行./school-rpc

可以看到COMMANDS 中增加了rpc 启动的服务选项（rpc）

第三步 启动服务

正常情况下，当前的服务启动成功了

第四步 启动grpc-ui

如果之前还没有安装的话，可以参考 “准备” 进行安装
grpcui -plaintext 127.0.0.1:8980 执行这个命令，注意host 和 port和 我们启动的服务保持一致即可
它会弹出一个UI页面，我们可以在这个页面上面进行调试

更多相关信息，，https://t.me/gtokentool