go gprc 使用 教程

技术栈

grpc
go
protobuff

1.环境

1.1. 安装protoc

项目地址 https://github.com/protocolbuffers/protobuf

下载protobuff, 有条件的github上直接下载，github下载地址，或者可以从maven仓库下载

在maven仓库中找到对应的版本，进行下载，linux ,windows 都有

1589089027209.png

这里我下载 windows 64 位的这个

下载下来的是可执行文件，直接放到环境变量里面，这个文件名太长了，把后缀都去掉

我放的路径 %GOPATH%\bin\protoc.exe

1.2. 安装 protoc-gen-go

直接go get -u github.com/golang/protobuf/protoc-gen-go

go get 的比较慢的话可以用代理。需要配置下代理。

看下 %GOPATH%\bin\ 有没有protoc-gen-go.exe ，没有的话需要找到下载的包进行安装。

下载目录在：%GOPATH%\pkg\mod\github.com\golang\protobuf@xxx\protoc-gen-go

进入目录然后 go install ，然后再去看bin 目录就会生成protoc-gen-go.exe

1589090845985.png

2. 建项目实践

1. 建目录 grpcprj

go mod init grpcprj

这个是我创建后的目录

|   go.mod #工程文件
|   go.sum #工程文件
+---client #客户端代码存放目录
|       main.go 
+---proto #proto 文件存放目录，包括通过protoc 编译后的文件
|   \---hello
|           hello.pb.go #protoc 根据proto文件生成的go项目文件
|           hello.proto #proto 文件
\---server #服务端代码
    |   main.go
    \---handler #服务端接口实现
            hello.go

2. 编写proto文件

syntax="proto3"; //版本

package go.rpc.srv.hello; //作用域

service Hello{ //service 表示服务，在这里面定义接口
 //定义了一个接口SayHello 接收了一个Say消息，返回一个Say消息
 rpc SayHello(Say) returns (Say);  
}

// 定义一个结构体，Say
message Say {
string name = 1; // 定义格式如下 ：<修饰符> 类型 字段名 = 唯一编号

//由于一些历史原因，基本数值类型的repeated的字段并没有被尽可能地高效编码。
//在新的代码中，用户应该使用特殊选项[packed=true]来保证更高效的编码。
//注意[packed=true]只能用在 repeated修饰的数字类型中
//repeated用来定义数组
repeated  int32 list =2; //repeated 

//定义map
map<string, string> maps = 3;

//有时候你需要保留一些你以后要用到的编号或者变量名，使用reserved关键字
reserved 3, 15, 9 to 11; //保留 3，15，9到11
reserved "foo", "bar";

//string var2 = 3;//编译会报错，因为3被保留了
//string var3 = 10;//编译会报错，因为10被保留了
//string foo = 12;//编译会报错，因为foo被保留了
}

消息体可以嵌套，也可以引入其他的proto文件

import "google/protobuf/any.proto"; //引入其他文件

//消息嵌套
message ParentBean{
    ChildA child = 1;
    message ChildB{
        string name = 1;
    } 
    ChildB child2 = 2 ;
}
message ChildA{
    string name = 1;
}

字段类型对比

3. 编译proto文件

​ proto 文件编写完毕以后，使用protoc 进行编译，编译成成 xxx.pb.go，编译是干什么呢？

protoc --go_out=plugins=grpc:. proto/hello/hello.proto

​ 运行命令后会在 proto 文件同目录生成 xxx.pb.go,对应的service 会成生成一个空的实现（指的是只做了实现，并没有具体业务功能），这里需要注意的是，默认go环境变量已经配置正确，gopath\bin 在环境变量里面。

hello.proto（最简的）

syntax="proto3";

service Hello{
    rpc SyaHello(Say) returns (Say);
}

message Say {
  string name = 1;
}

编译后的文件

...省略了其他代码
// HelloServer is the server API for Hello service.
// helloServer 接口
type HelloServer interface { 
    SyaHello(context.Context, *Say) (*Say, error)
}

// UnimplementedHelloServer can be embedded to have forward compatible implementations.

type UnimplementedHelloServer struct {
}

// 以下是一个空的实现，没有实现任何业务逻辑
func (*UnimplementedHelloServer) SyaHello(context.Context, *Say) (*Say, error) {
    return nil, status.Errorf(codes.Unimplemented, "method SyaHello not implemented")
}

4. 实现服务端接口逻辑

​ 服务端可以实现，也可以不实现，也可以改下上面的默认生成的这个实现类，这里重新实现了下，里面写自己的业务逻辑。

server/handler/hello.go(最简实现)

package handler

import (
    "context"
    "fmt"
    h "grpcprj/proto/hello"
    )

type HelloImpl struct {}

func (hi *HelloImpl)SyaHello(ctx context.Context,in *h.Say) (*h.Say, error){
    msg:=fmt.Sprintf("echo say:%s",in.GetName())
    return &h.Say{Name:msg},nil
}

5. 服务端代码

package main

import (
 "context"
 "google.golang.org/grpc"
 h "grpcprj/proto/hello"
 "log"
 "time"
)

var(
 addr  ="localhost:8081"
 defmsg = "hello boger"
)

func main()  {

 var(
     conn *grpc.ClientConn
     ctx context.Context
     cancel context.CancelFunc
     err error
     r *h.Say
 )

 if conn,err=grpc.Dial(addr,grpc.WithInsecure(),grpc.WithBlock());err!=nil{
     log.Fatalf("conn server err :%v",err)
 }
 defer conn.Close()
 c := h.NewHelloClient(conn)

 ctx,cancel=context.WithTimeout(context.Background(),time.Second)
 defer cancel()
 if r,err=c.SyaHello(ctx,&h.Say{Name:defmsg});err!=nil{
     log.Fatalf("get error :%v",err)
 }
 log.Printf("get msg :%s",r.Name)
}

6. 客户端代码

​ protoc 生成的go 代码里面包括服务端的定义，和客户端的定义（协议的打包，解包都包括了）

​ grpcprj/client/hello.go

package main

import (
    "context"
    "google.golang.org/grpc"
    h "grpcprj/proto/hello"
    "log"
    "time"
)

var(
    addr  ="localhost:8081"
    defmsg = "hello boger"
)

func main()  {

    var(
        conn *grpc.ClientConn
        ctx context.Context
        cancel context.CancelFunc
        err error
        r *h.Say
    )

    if conn,err=grpc.Dial(addr,grpc.WithInsecure(),grpc.WithBlock());err!=nil{
        log.Fatalf("conn server err :%v",err)
    }
    defer conn.Close()
    c := h.NewHelloClient(conn)

    ctx,cancel=context.WithTimeout(context.Background(),time.Second)
    defer cancel()
    if r,err=c.SyaHello(ctx,&h.Say{Name:defmsg});err!=nil{
        log.Fatalf("get error :%v",err)
    }
    log.Printf("get msg :%s",r.Name)
}