golang grpc配置使用实战教程-Toy模板网

这篇具有很好参考价值的文章主要介绍了golang grpc配置使用实战教程。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

什么是PRC&GRPC

RPC是远程过程调用（Remote Procedure Call）的缩写形式, RPC 的主要功能目标是让构建分布式计算（应用）更容易，在提供强大的远程调用能力时不损失本地调用的语义简洁性。通俗地讲，使用RPC进行通信，调用远程函数就像调用本地函数一样，RPC底层会做好数据的序列化与传输。 下图是dubbo rpc实现的图解，以便于大家理解RPC：
golang grpc配置使用实战教程
GRPC是rpc框架的实现，是一个基于Protobuf序列化协议开发的高性能，开源和通用的RPC框架，且支持众多开发语言。

golang grpc配置使用实战教程
从图中还可以看出，proto文件的编译支持多种语言（Go、Java、Python等）,可以轻松实现跨语言调用。

RPC调用之前需要进行IDL文件定义编写和对应语言调用模板方法生成（protoc自动生成）

RPC调用大致步骤：

客户端建立连接(gRPC Stub)并调用A方法，发起RPC调用
gRPC框架对请求信息使用Protobuf进行对象序列化压缩（IDL）
服务端（gPRC Server)接收到请求后，解码反序列化，进行业务逻辑处理并返回。
对响应结果使用Protobuf进行对象序列化压缩（IDL）
客户端接受到服务端响应，解码发序列化。回调被调用的A方法，唤醒正在等待响应（阻塞）的客户端调用并返回响应结果。

Go gRPC 环境准备

本人是在WSL环境（window linux 子系统）进行的，window 和 mac 可以自行尝试，原理和步骤都一样。

Go 语言环境安装，下载对应的安装包，配置GOPATH、GOROOT、GOPROXY，以及GO111MODULE 设置为on，具体安装和配置细节可参考官网和其他教程，这里列出自己的go env信息：

# GO111MODULE on模式
GO111MODULE="on"
GOARCH="amd64"
GOBIN=""
GOCACHE="/home/lizheng/.cache/go-build"
GOENV="/home/lizheng/.config/go/env"
GOEXE=""
GOEXPERIMENT=""
GOFLAGS=""
GOHOSTARCH="amd64"
GOHOSTOS="linux"
GOINSECURE=""
GOMODCACHE="/home/lizheng/gopath/pkg/mod"
GONOPROXY=""
GONOSUMDB=""
GOOS="linux"
# GOPATH 配置
GOPATH="/home/lizheng/gopath"
GOPRIVATE=""
# GOPROXY 配置
GOPROXY="https://goproxy.cn"
# GOROOT 配置
GOROOT="/home/lizheng/go"
GOSUMDB="sum.golang.org"
GOTMPDIR=""
GOTOOLDIR="/home/lizheng/go/pkg/tool/linux_amd64"
GOVCS=""
GOVERSION="go1.17.7"
GCCGO="gccgo"
AR="ar"
CC="gcc"
CXX="g++"
CGO_ENABLED="1"
GOMOD="/dev/null"
CGO_CFLAGS="-g -O2"
CGO_CPPFLAGS=""
CGO_CXXFLAGS="-g -O2"
CGO_FFLAGS="-g -O2"
CGO_LDFLAGS="-g -O2"
PKG_CONFIG="pkg-config"
GOGCCFLAGS="-fPIC -m64 -pthread -fmessage-length=0 -fdebug-prefix-map=/tmp/go-build1495300227=/tmp/go-build -gno-record-gcc-switches"

Protocol buffer 编译器配置
这里的Protocol buffer编译器用来编译 .proto RPC协议定义文件，自动生成对应语言的目标代码，减少开发量。安装步骤参考：protoc 安装文档

lizheng@lz-x:~$  apt install -y protobuf-compiler
lizheng@lz-x:~$ protoc --version
libprotoc 3.6.1

Protocol buffer Go语言编译插件配置安装
因为我们使用的是go语言实现grpc，所以 protoc 命令在执行编译的时候，会调用go语言插件，来生成golang代码。

lizheng@lz-x:~$ go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.28
lizheng@lz-x:~$ go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@v1.2

注意：这里安装完成之后，会将对应命令安装到gopath配置目录下的bin文件夹下如下图
golang grpc配置使用实战教程
我们需要确保bin下文件命令可以被全局访问到，配置到PATH中即可，如果是window需要配置到环境变量path中

实战编写和调用

经过上述步骤环境已经完成配置，我们开始一个helloword的程序开发，包括服务端和客户端两部分。

新建一个文件夹 my-grpc，使用 go mod init example.com/ggrpc初始化项目
建立子文件夹：client、server、proto，分别存储客户端、服务端、grpc存根文件。
进入proto，新建一个 helloworld.proto 文件，编写一下内容：

// 使用的语法协议版本 proto3
syntax = "proto3";
package proto;
// 定义生成go文件的package位置和名称
option go_package = "./;proto";

// 定义Greeter服务
service Greeter {
    // 定义SayHello方法，接受HelloRequest消息， 并返回HelloReply消息
    rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// 定义请求对象
message HelloRequest {
    string name = 1;
}

// 定义返回对象
message HelloReply {
    string message = 1;
}

上面只是一个简单的定义，细节proto语法可自行官网学习

执行protoc命令，生成目标语言文件

# \ 为命令换行但不执行，可以写一行那就不需要 \ 了
protoc --go_out=. --go_opt=paths=source_relative \
    --go-grpc_out=. --go-grpc_opt=paths=source_relative \
    helloworld.proto

执行成功会生成：helloworld.pb.go 和 helloworld_grpc.pb.go 两个文件
golang grpc配置使用实战教程
5. 执行 go mod tidy 下载依赖包，主要是grpc相关的包
6. 编写服务端和客户端代码

服务端

package main

import (
	"context"
	"flag"
	"fmt"
	"log"
	"net"
	"time"

	h "example.com/ggrpc/handler"
	pb "example.com/ggrpc/proto"
	"google.golang.org/grpc"
)

var (
	port = flag.Int("port", 8000, "The server port")
)
// 定义一个server实现UnimplementedGreeterServer
// UnimplementedGreeterServer 是第四步自动生成的，可以打开对应文件查看
type server struct {
	pb.UnimplementedGreeterServer
}

// server 重写SayHello方法，做业务处理
func (s *server) SayHello(c context.Context, req *pb.HelloRequest) (*pb.HelloReply, error) {
	log.Printf("接收到客户端的消息: %v", req.GetName())
	time.Sleep(time.Second)
	ms := fmt.Sprintf("好的收到,%s %s", req.GetName(), time.Now())
	log.Printf("回复客户端的消息: %s", ms)
	return &pb.HelloReply{Message: ms}, nil
}

func main() {
	// 解析命令行参数
	flag.Parse()
	// 监听本地tcp端口
	lis, err := net.Listen("tcp", fmt.Sprintf(":%d", *port))
	if err != nil {
		log.Fatalf("failed to listen: %v", err)
	}
	// 创建一个grpc Server服务对象,Handler非必传
	// s := grpc.NewServer() // 可以直接创建对象
	s := grpc.NewServer(grpc.StatsHandler(&h.MyHandler{}))
	// 注册服务
	pb.RegisterGreeterServer(s, &server{})
	// 启动RPC并监听
	log.Printf("server listening at %v", lis.Addr())
	if err := s.Serve(lis); err != nil {
		log.Fatalf("failed to serve: %v", err)
	}
}

客户端

package main

import (
	"context"
	"flag"
	"log"
	"time"

	pb "example.com/ggrpc/proto"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

var serAddr = flag.String("addr", "localhost:8000", "the address to connect to")

func main() {
	// 解析命令行参数
	flag.Parse()

	// 连接服务端
	conn, err := grpc.Dial(*serAddr, grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		log.Fatalf("连接服务器失败: %v", err)
	}
	log.Printf("建立连接成功: %s", *serAddr)
	// 执行完方法自动关闭资源
	defer conn.Close()

	// 创建客户端
	c := pb.NewGreeterClient(conn)

	log.Println("5秒中之后调用SayHello方法")
	time.Sleep(time.Second * 5)
	// 创建2秒超时ctx
	ctx, cancel := context.WithTimeout(context.Background(), time.Second*2)
	defer cancel()
	// 发起RPC请求
	log.Println("开始调用SayHello方法")
	res, err := c.SayHello(ctx, &pb.HelloRequest{Name: "一号"})
	if err != nil {
		log.Fatalf("请求失败: %v", err)
	}
	log.Printf("请求结果: %s", res.GetMessage())

	// 睡眠一会再结束
	log.Println("3秒后结束，客户端自动断开连接")
	time.Sleep(time.Second * 3)

}

因为本人测试加了一个server端的handler，给出handle的代码，可以忽略文章来源地址https://www.toymoban.com/news/detail-435799.html

package handler

import (
	"context"
	"log"

	"google.golang.org/grpc/stats"
)

// 自定义handler实现stats.Handler打印一些信息
type MyHandler struct {
}

func (h *MyHandler) TagRPC(c context.Context, tag *stats.RPCTagInfo) context.Context {
	log.Printf("TagRPC: %v", tag)
	return c
}

func (h *MyHandler) HandleRPC(c context.Context, s stats.RPCStats) {
	log.Printf("HandleRPC: %v", s)
}

func (h *MyHandler) TagConn(c context.Context, tag *stats.ConnTagInfo) context.Context {
	log.Printf("TagConn: %v", tag)
	return c
}
func (h *MyHandler) HandleConn(c context.Context, s stats.ConnStats) {
	log.Printf("HandleConn: %v", s)
}