gRPC 入门使用教程

最新推荐文章于 2024-09-22 10:47:27 发布
最新推荐文章于 2024-09-22 10:47:27 发布
阅读量5.5k 收藏 41
点赞数 12
分类专栏： Go 文章标签： 网络 java 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43580193/article/details/127577709
版权

gRPC 入门使用教程

一、gRPC 介绍

在 gRPC 里客户端应用可以像调用本地对象一样直接调用另一台不同的机器上服务端应用的方法，使得您能够更容易地创建分布式应用和服务。与许多 RPC 系统类似，gRPC 也是基于以下理念：定义一个服务，指定其能够被远程调用的方法（包含参数和返回类型）。在服务端实现这个接口，并运行一个 gRPC 服务器来处理客户端调用。在客户端拥有一个存根能够像服务端一样的方法。

图1

二、安装与使用

安装 protoc 程序：

从 https://github.com/google/protobuf/releases下载适合你平台的预编译好的二进制文件（protoc-<version>-<platform>.zip），然后将压缩包内的 /bin/protoc 文件添加到环境变量即可：

# 下载压缩包
wget https://github.com/protocolbuffers/protobuf/releases/download/v21.9/protoc-21.9-linux-x86_64.zip

# 解压
unzip -d ./protoc protoc-21.9-linux-x86_64.zip

# 移动到 /usr/local/bin 下面
mv ./protoc/bin/protoc /usr/local/bin

首先需要确保将 GOBIN 添加进了环境变量，如果没有添加使用的时候会无法找到路径。Linux 环境下可通过以下指令添加：

export GOPATH=$HOME/go
export GOBIN=$GOPATH/bin
export PATH=$PATH:$GOPATH/bin

安装 protoc-gen-go 和 protoc-gen-go-grpc 插件：

# protoc-gen-go 插件主要用于将 *.proto 文件生成一个后缀为 *.pb.go 的文件。生成文件中包含所有 .proto 文件中定义的类型及其序列化方法
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest

# protoc-gen-go-grpc 插件主要用于生成 gRPC 服务端需要实现的接口和客户端调用的接口
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

测试环境安装是否成功：

> protoc --version
libprotoc 3.21.9

> protoc-gen-go --version
protoc-gen-go v1.28.1

> protoc-gen-go-grpc --version
protoc-gen-go-grpc 1.2.0

三、protobuff 语法

proto 文件主要包含 proto 基本信息以及 RPC 服务定义。

进行一次 RPC 调用需要注意两个点：方法和参数。在 porro 文件中，方法用 Service 定义，参数用 Message 定义。

1. 基本信息

// 版本声明，使用Protocol Buffers v3版本
syntax = "proto3";

// package 是 proto 的包名,一个文件就是一个 package,用于 import 时解析(与 go 的包管理类似)
package pb;

// option go_package = "path;name";
// path 表示生成的go文件的存放地址，会自动生成目录的。
// name 表示生成的go文件所属的包名
option go_package = "./;pb";

2. message

一个 Message 中主要包含：字段编号和字段类型；

字段编号

消息定义中的每个字段都有一个唯一的编号。这些字段编号用来在消息二进制格式中标识字段，在消息类型使用后就不能再更改。

注意，范围1到15中的字段编号需要一个字节进行编码，包括字段编号和字段类型。范围16到2047的字段编号采用两个字节。因此，应该为经常使用的消息元素保留数字1到15的编号。切记为将来可能添加的经常使用的元素留出一些编号。

字段类型

字段类型包含标量类型、组合类型、枚举类型、数组类型、map 类型和嵌套消息；

2.1 标量类型

下表中列举了 protobuff 中的类型与常见编程语言中类型的对应关系：

NotesC++Java/KotlinPythonGo
doubledoubledoublefloatfloat64
floatfloatfloatfloatfloat32
int32使用可变长度编码。编码负数效率低下——如果你的字段可能有负值，则使用 sint32代替。int32intintint32
int64使用可变长度编码。编码负数效率低下——如果你的字段可能有负值，则使用 sint64代替。int64longint/long[4]int64
uint32使用变长编码。uint32int[2]int/long[4]uint32
uint64使用变长编码。uint64long[2]int/long[4]uint64
sint32使用可变长度编码。带符号的 int 值。这些编码比普通的 int32更有效地编码负数。int32intintint32
sint64使用可变长度编码。带符号的 int 值。这些编码比普通的 int64更有效地编码负数。int64longint/long[4]int64
fixed32总是四个字节。如果值经常大于228，则比 uint32更有效率。uint32int[2]int/long[4]uint32
fixed64总是8字节。如果值经常大于256，则比 uint64更有效率。uint64integer/string[6]
sfixed32总是四个字节。int32intintint32
sfixed64总是八个字节。int64integer/string[6]
boolboolbooleanboolbool
string字符串必须始终包含 UTF-8编码的或7位 ASCII 文本，且不能长于232。stringStringstr/unicode[5]string
bytes可以包含任何不超过232字节的任意字节序列。stringByteStringstr (Python 2) bytes (Python 3)[]byte

examples：

message HelloRequest {
	string name = 1;
	int64 age = 2;
	bool man = 3;
}
2.2 枚举类型

当需要定义一个消息类型的时候，可能想为一个字段指定 “预定义值序列” 中的一个值，这时候可以通过枚举实现。

enum PhoneType // 枚举消息类型，使用 enum 关键词定义
{
    MOBILE = 0; // proto3 版本中，枚举类型首成员必须为0，成员不应有相同的值
    HOME = 1;
    WORK = 2;
}

// 定义一个电话消息
message PhoneNumber
{
    string number = 1;
    PhoneType type = 2; 
}
2.3 数组类型

在 protobuf 消息中定义数组类型，是通过在字段前面增加 repeated 关键词实现，标记当前字段是一个数组。

message Msg {
	repeated int32 arrays = 1;
	repeated string strings = 2;
}
2.4 map 类型

map 类型的定于语法为：

map<key_type, value_type> map_field = N;

key_type可以是任何整数或字符串类型（除浮点类型和字节之外的任何标量类型）。请注意，枚举不是有效的key_type。

示例：

message Msg {
	map<string, int> dictA = 1;
	map<string, string> dictB = 2;
}
2.5 嵌套类型

我们在各种语言开发中类的定义是可以互相嵌套的，也可以使用其他类作为自己的成员属性类型。

在 protobuf 中同样支持消息嵌套，可以在一个消息中嵌套另外一个消息，字段类型可以是另外一个消息类型。

引用其他消息类型

message Msg1 {
	string name = 1;
	int32 age = 2;
}

message Msg2 {
	string describe = 1;
	Msg1 msg = 2;
}

消息嵌套

message Msg1 {
	message Msg2 {
		string name = 1;
		string age = 2;
	}
	Msg2 msg = 1;
}

import 导入其他 proto 文件定义的消息

msg1.proto:

syntax = "proto3";

package msg1;

message Msg1 {
	string name = 1;
	string age = 2;
}

msg2.proto:

syntax = "proto3";

import "msg1.proto";

package msg2;

message Msg2 {
	msg1.Msg1 msg = 1;
}

3. Service

在 gRPC 中，可以定义四种类型的服务方法：

  • 简单RPC (simple RPC)：客户端向服务器发送一个请求，然后得到一个响应，就像普通的函数调用一样：

    rpc SimpleRPC(HelloRequest) returns (HelloResponse);

  • 服务端流式RPC (server-side streaming RPC)：客户端向服务端发送一个请求，服务端返回客户端一个流。客户端可以从这个流中读取，直到服务端关闭这个流：

    rpc ServerSideStreamingRPC(HelloRequest) returns (stream HelloResponse);

  • 客户端流式RPC (client-side streaming RPC)：客户端向服务端发起一个流式请求。客户端可以向流中多次写入数据，服务端从流中多次取出数据，直到客户端关闭流。服务端接收完所有数据后，向客户端返回一个普通响应：

    rpc ClientSideStreamingRPC(stream HelloRequest) returns (HelloResponse);

  • 双向流式RPC (bidirectional streaming RPC)：客户端向服务端发起一个流式请求，服务端向客户端返回一个流式响应。两个流之间相互独立，互不影响：

    rpc BidrectionalStreamingRPC(stream HelloRequest) returns (stream HelloResponse);

将需要定义的 RPC 调用写入 Service 字段：

service Greeter {
  rpc SimpleRPC(HelloRequest) returns (HelloResponse);

  rpc ServerSideStreamingRPC(HelloRequest) returns (stream HelloResponse);

  rpc ClientSideStreamingRPC(stream HelloRequest) returns (HelloResponse);

  rpc BidrectionalStreamingRPC(stream HelloRequest) returns (stream HelloResponse);
}

四、gRPC 示例

首先建一个 Go 的工程：

go mod init grpcDemo

然后导入 gRPC 包：

go get google.golang.org/grpc@latest

当前目录结构为：

.
├── go.mod
└── go.sum

1. 编写 protobuff 代码

新建一个 pb 目录，编写 demo.proto 文件：

syntax = "proto3";

option go_package = "./;pb";
package pb;

service Greeter {
  // 简单 RPC
  rpc SimpleRPC(HelloRequest) returns (HelloResponse);

  // 服务端流式 RPC
  rpc ServerSideStreamingRPC(HelloRequest) returns (stream HelloResponse);

  // 客户端流式 RPC
  rpc ClientSideStreamingRPC(stream HelloRequest) returns (HelloResponse);

  // 双端流式 RPC
  rpc BidrectionalStreamingRPC(stream HelloRequest) returns (stream HelloResponse);
}

message HelloRequest {string name = 1;}

message HelloResponse {string reply = 1;}

当前目录结构为：

.
├── go.mod
├── go.sum
└── pb
    └── demo.proto

通过以下命令将 .proto 文件生成 .go 文件：

protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative pb/demo.proto

执行命令后会在当前文件夹下生成两个 .go 文件：

.
├── go.mod
├── go.sum
└── pb
    ├── demo.pb.go
    ├── demo.proto
    └── demo_grpc.pb.go

2. 编写 Go 代码

新建一个 server和client 目录，创建 server.go和client.go 文件进行服务端和客户端代码编写。

2.1 Simple RPC

服务端

package main

import (
	"context"
	"grpcDemo/pb"
	"log"
	"net"

	"google.golang.org/grpc"
)

type server struct {
    // 继承 protoc-gen-go-grpc 生成的服务端代码
	pb.UnimplementedGreeterServer
}

// SimplePRC 服务端代码
func (s *server) SimpleRPC(ctx context.Context, in *pb.HelloRequest) (*pb.HelloResponse, error) {
	log.Println("client call simpleRPC...")

	log.Println(in)
	return &pb.HelloResponse{Reply: "Hello " + in.Name}, nil
}

func main() {
    // 监听本地 5678 端口
	listen, err := net.Listen("tcp", ":5678")
	if err != nil {
		log.Fatal(err)
		return
	}

    // 创建 gRPC 服务器
	s := grpc.NewServer()
    // 将实现的接口注册进 gRPC 服务器
	pb.RegisterGreeterServer(s, &server{})
	log.Println("gRPC server starts running...")
    // 启动 gRPC 服务器
	err = s.Serve(listen)
	if err != nil {
		log.Fatal(err)
		return
	}
}

客户端

package main

import (
	"context"
	"grpcDemo/pb"
	"io"
	"log"

	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

func simpleRPC(c pb.GreeterClient) {
	ctx := context.Background()
    // 调用服务端 SimpleRPC 并获取响应
	reply, err := c.SimpleRPC(ctx, &pb.HelloRequest{Name: "simpleRPC"})
	if err != nil {
		log.Fatal(err)
	}
	log.Println(reply.GetReply())
}

func main() {
    // 连接服务端，因为我们没有SSL证书，因此这里需要禁用安全传输
	dial, err := grpc.Dial("127.0.0.1:5678", grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		log.Fatal(err)
		return
	}
	defer dial.Close()
	
	conn := pb.NewGreeterClient(dial)
	simpleRPC(conn)
}

当前目录结构：

.
├── client
│   └── client.go
├── go.mod
├── go.sum
├── pb
│   ├── demo.pb.go
│   ├── demo.proto
│   └── demo_grpc.pb.go
└── server
    └── server.go

分别使用两个终端运行服务端和客户端的代码:

> go run server/server.go 
2022/10/27 08:55:59 gRPC server starts running...
2022/10/27 08:56:41 client call simpleRPC...
2022/10/27 08:56:41 name:"simpleRPC"

> go run client/client.go 
2022/10/27 08:56:41 Hello simpleRPC
2.2 服务端流式 RPC
// server.go
func (s *server) ServerSideStreamingRPC(in *pb.HelloRequest, stream pb.Greeter_ServerSideStreamingRPCServer) error {
	log.Println("client call ServerSideStreamingRPC...")
	words := []string{
		"你好",
		"hello",
		"こんにちは",
		"안녕하세요",
	}

	for _, word := range words {
		data := &pb.HelloResponse{
			Reply: word + " " + in.Name,
		}
		
        // 向流中不断写入数据
		if err := stream.SendMsg(data); err != nil {
			return err
		}
	}
	return nil
}

// client.go
func serverSideStreamRPC(c pb.GreeterClient) {
	ctx := context.Background()
    // 调用服务端方法
	stream, err := c.ServerSideStreamingRPC(ctx, &pb.HelloRequest{Name: "gRPC!"})
	if err != nil {
		log.Fatal(err)
	}
	for {
		// 接收服务端返回的流式数据，当收到io.EOF或错误时退出
		res, err := stream.Recv()
        // 判断流是否关闭
		if err == io.EOF {
			break
		}
		if err != nil {
			log.Fatal(err)
		}
		log.Printf("got reply: %q\n", res.GetReply())
	}
}

分别使用两个终端运行服务端和客户端的代码:

> go run server/server.go 
2022/10/27 09:02:59 gRPC server starts running...
2022/10/27 09:03:23 client call ServerSideStreamingRPC...

> go run client/client.go 
2022/10/27 09:03:23 got reply: "你好 gRPC!"
2022/10/27 09:03:23 got reply: "hello gRPC!"
2022/10/27 09:03:23 got reply: "こんにちは gRPC!"
2022/10/27 09:03:23 got reply: "안녕하세요 gRPC!"
2.3 客户端流式 RPC
// server.go
func (s *server) ClientSideStreamingRPC(stream pb.Greeter_ClientSideStreamingRPCServer) error {
	log.Println("client call ClientSideStreamingRPC...")
	reply := "Hello: "
	for {
        // 从流中接收客户端发送的数据
		res, err := stream.Recv()
        // 判断流是否关闭
		if err == io.EOF {
			return stream.SendAndClose(&pb.HelloResponse{Reply: reply})
		}

		if err != nil {
			return err
		}

		reply += ", " + res.GetName()
	}
}

// client.go
func clientSideStreamRPC(c pb.GreeterClient) {
	ctx := context.Background()
    // 调用服务端方法
	stream, err := c.ClientSideStreamingRPC(ctx)
	if err != nil {
		log.Fatal(err)
	}

	names := []string{"a1", "a2", "a3", "a4"}
	for _, name := range names {
        // 向流中不断写入数据
		err := stream.Send(&pb.HelloRequest{Name: name})
		if err != nil {
			log.Fatal(err)
		}
	}

    // 向服务端发送关闭流的信号，并接收数据
	res, err := stream.CloseAndRecv()
	if err != nil {
		log.Fatal(err)
	}
	log.Println(res.Reply)
}

分别使用两个终端运行服务端和客户端的代码:

> go run server/server.go 
2022/10/27 09:17:04 gRPC server starts running...
2022/10/27 09:17:11 client call ClientSideStreamingRPC...

> go run client/client.go 
2022/10/27 09:17:11 Hello: , a1, a2, a3, a4
2.4 双端流式 RPC
// server.go
func (s *server) BidrectionalStreamingRPC(stream pb.Greeter_BidrectionalStreamingRPCServer) error {
	log.Println("client call BidrectionalStreamingRPC...")
	for {
        // 接收来自客户端的数据
		res, err := stream.Recv()
		if err == io.EOF {
			return nil
		}
		if err != nil {
			return err
		}

		reply := "Hello " + res.GetName()
        // 向客户端发送数据
		if err := stream.Send(&pb.HelloResponse{Reply: reply}); err != nil {
			return err
		}
	}
}

// client.go
func bidStreamRPC(c pb.GreeterClient) {
    // 调用服务端方法
	stream, err := c.BidrectionalStreamingRPC(context.Background())
	if err != nil {
		log.Fatal(err)
	}

	names := []string{"a1", "a2", "a3", "a4"}
	for _, name := range names {
        // 向服务端发送数据
		err := stream.Send(&pb.HelloRequest{Name: name})
		if err != nil {
			log.Fatal(err)
		}

        // 从客户端接收数据
		reply, err := stream.Recv()
		if err != nil {
			log.Fatal(err)
		}
		log.Println(reply.GetReply())
	}

    // 关闭流
	err = stream.CloseSend()
	if err != nil {
		log.Fatal(err)
	}
}

分别使用两个终端运行服务端和客户端的代码:

> go run server/server.go 
2022/10/27 09:20:51 gRPC server starts running...
2022/10/27 09:26:26 client call BidrectionalStreamingRPC...

> go run client/client.go 
2022/10/27 09:26:26 Hello a1
2022/10/27 09:26:26 Hello a2
2022/10/27 09:26:26 Hello a3
2022/10/27 09:26:26 Hello a4

3. gRPC 使用 Unix Socket 通信

gRPC 默认使用的是 TCP 通信。但是如果想仅仅在本机进行进程间通信，就没必要过一层网络接口了，直接使用 unix socket 即可。

// server.go
package main
  
import (
        "context"
        "grpcDemo/pb"
        "log"
        "net"
        "os"

        "google.golang.org/grpc"
)

type server struct {
        pb.UnimplementedGreeterServer
}

// 实现 SimpleRPC 方法
func (s *server) SimpleRPC(ctx context.Context, in *pb.HelloRequest) (*pb.HelloResponse, error) {
        log.Println("client call simpleRPC...")
        log.Println(in)
        return &pb.HelloResponse{Reply: "Hello " + in.Name}, nil
}

// 移除存在的 unix socket 文件
func removeExistedSock(file string) {
        stat, err := os.Stat(file)
        if err == nil {
                if stat.Mode().Type() == os.ModeSocket {
                        err := os.Remove(file)
                        if err != nil {
                                log.Fatal(err)
                        }
                }
        }
}

func main() {
        removeExistedSock("/tmp/default.sock")
    	// 解析 unix socket 地址
        addr, err := net.ResolveUnixAddr("unix", "/tmp/default.sock")
        if err != nil {
                log.Fatal(err)
                return
        }
    	// 监听 unix socket 文件
        unix, err := net.ListenUnix("unix", addr)
        if err != nil {
                log.Fatal(err)
                return
        }

        s := grpc.NewServer()
    	// 绑定 unix socket 连接
        pb.RegisterGreeterServer(s, &server{})
    	log.Println("gRPC server starts running...")
    	// 启动服务
        err = s.Serve(unix)
        if err != nil {
                log.Fatal(err)
                return
        }
}

package main
  
import (
        "context"
        "grpcDemo/pb"
        "log"
        "net"

        "google.golang.org/grpc"
        "google.golang.org/grpc/credentials/insecure"
)


func simpleRPC(c pb.GreeterClient) {
        ctx := context.Background()
        reply, err := c.SimpleRPC(ctx, &pb.HelloRequest{Name: "simpleRPC"})
        if err != nil {
                log.Fatal(err)
        }
        log.Println(reply.GetReply())
}

// 被 gRPC 框架调用，创建 unix socket 连接
func UnixConnect(ctx context.Context, addrs string) (net.Conn, error) {
        addr, err := net.ResolveUnixAddr("unix", addrs)
        if err != nil {
                return nil, err
        }
        conn, err := net.DialUnix("unix", nil, addr)
        if err != nil {
                return nil, err
        }
        return conn, nil
}

func main() {
    	// 创建 gRPC 连接客户端
        conn, err := grpc.Dial("/tmp/default.sock", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithContextDialer(UnixConnect))
        if err != nil {
                log.Fatal(err)
                return
        }
		
    	// 创建当前 protobuff 的客户端对象
        client := pb.NewGreeterClient(conn)
        simpleRPC(client)
}

分别使用两个终端运行服务端和客户端的代码:

> go run server1/server.go 
2022/10/27 09:59:16 gRPC server starts running...
2022/10/27 10:01:47 client call simpleRPC...
2022/10/27 10:01:47 name:"simpleRPC"

> go run client1/client.go 
2022/10/27 10:01:47 Hello simpleRPC
执笔苦行僧
关注
专栏目录
grpc入门教程
qq_29258467的博客
07-07 1645
grpc入门教程1.1 grpc是什么1.2 为什么要使用rpc2 使用grpc创建一个rpc服务2.1 创建xxx.proto文件，定义服务，设计api 1.1 grpc是什么 gRPC 是一个高性能、开源和通用的 RPC 框架，面向移动和 HTTP/2 设计。目前提供 C、Java 和 Go 语言版本，分别是：grpc, grpc-java, grpc-go. 其中 C 版本支持 C, C++, Node.js, Python, Ruby, Objective-C, PHP 和 C# 支持. 1.2
gRPC-Go入门教程
perfume
01-02 790
protobuf简介 Protocol Buffers(protobuf)：与编程语言无关，与程序运行平台无关的数据序列化协议以及接口定义语言(IDL: interface definition language)。 要使用protobuf需要先理解几个概念： protobuf编译器protoc，用于编译.proto文件 开源地址：https://github.com/protocolbuffers/protobuf 编程语言的protobuf插件，搭配protoc编译器，
gRPC入门教程(二)---gRPC简单使用
探索云原生
07-22 3321
本文主要对 gRPC 框架做了简单的介绍，同时记录了具体安装方法与基本使用教程。 更多文章欢迎访问我的个人博客–>幻境云图 1. 概述 gRPC 是一个高性能、通用的开源RPC框架，其由Google主要面向移动应用开发并基于HTTP/2协议标准而设计，基于ProtoBuf(Protocol Buffers)序列化协议开发，且支持众多开发语言。 gRPC基于HTTP/2标准设计，带来诸如...
gRPC教程 — 调用实例详解_c# grpc
最新发布
2401_87361210的博客
09-22 333
Server端：有接口，结构体，方法等6个，需要注意的是服务端在使用前需要重写结构体并实现接口方法才行，否则会报错。：rpc相关的方法，分为（Client）客户端，（Server）服务端。Client端：有接口，结构体，建立客户端连接的方法。各个方法的末尾可以鉴别是客户端的方法还是服务端的方法。：结构体相关，每个结构体都有5个相同的方法，分别是。然后会生成service文件夹。
grpc使用教程
浅知拙见，欢迎指正
08-10 4322
protobuf、rpc使用详解
grpc的使用
HashFlag的博客
10-08 3077
1. 需要保证电脑中安装了：[protobuf安装教程](https://www.cnblogs.com/wylshkjj/p/16722735.html) 2. 如果出现报错请看博客：[protobuf报错问题解决](https://www.cnblogs.com/wylshkjj/p/16738686.html) 3. 基本使用demo地址：[demo](https://gitee.com/wylshkjj/grpc-demo) 4. 安全传输、流式传输的demo地址：[demo2](https://g
gRPC入门
qq_53267860的博客
05-30 2114
目录gRPC入门1. 什么是微服务1.1 单体架构1.2 微服务架构1.2.1 代码冗余问题1.2.2 服务之间调用2. gRPC3. protobuf3.1 安装3.2 hello world3.3 proto文件介绍3.3.1 message介绍3.3.2 字段规则3.3.3 字段映射3.3.4 默认值3.3.5 标识号3.3.6 定义多个消息类型3.3.7 嵌套消息3.3.8 定义服务(Service)4. gRPC实例4.1 RPC和gRPC介绍4.1.1 HTTP24.2 实例4.2.1 服务端4
gRPC详细入门教程，GolangPythonPHP多语言讲解.pdf
06-11
在Golang环境中，使用gRPC需要安装protoc工具，protoc-gen-go插件，以及grpc-go库。安装完成后，使用protoc命令生成Golang代码，并按照生成的代码结构编写服务端和客户端程序。 总的来说，gRPC提供了一种高效、灵活...
GRPC入门教程：高性能RPC框架解析与实践
"GRPC使用案例-GRPC入门及简单使用介绍" GRPC是一个由Google开发的高性能、通用性强的开源远程过程调用（RPC）框架，主要针对移动应用开发而设计。它基于HTTP/2协议标准，提供了一种现代化的方式来构建分布式微服务...
gRPC（1）：入门及简单使用（go）
Assassin
06-26 2721
1、RPC 1.1 什么是RPC RPC(Remote Procedure Call)，即远程过程调用，过程就是方法，简单来说，它就是一种能够像调用本地方法一样调用远程计算机进程中的方法的技术，在这种调用中，我们不需要了解任何网络通信的细节（当然，就使用来说） 最终解决的问题：让分布式或者微服务系统中不同服务之间的调用像本地调用一样简单 1.2 RPC和HTTP 调用远程服务，HTTP 就可以完成的任务，为什么还需要 RPC 呢？需要注意，这两个并不是同一层次的概念，HTTP 是一种传输协议，RPC 应该是
gRPC入门教程
Javaer
10-25 1081
gRPC 是 Google 开源的一个高性能的 RPC(Remote Procedure Call) 框架。(由Google内部RPC项目Stubby演化而来，2015年正式开源)低延迟、高度可扩展的分布式系统。开发与云服务器通信的移动客户端。设计一个需要准确、高效且独立于语言的新协议。分层设计以实现扩展，例如。身份验证、负载平衡、日志记录和监控等。网络通信协议序列化代理的创建gRPC自己封装了网络通信的部分，提供了多种语言的网络通信封装。
gRPC教程与应用
个人学习笔记库，一篇一篇记录成长的足迹
06-21 7325
grpc直接实现了新的服务器，并允许用户自定义接口，在服务器中暴露这些接口，在程序中整合grpc服务器，然后将接口绑定到程序的方法，客户端在连接rpc服务器是调用接口，则会直接指向服务器程序的方法，因此就行在本地调用一样。grpc是使用期本身的语法定义接口的，在上面的例子中使用了go语言，将接口绑定到go语言的接口中，那么如果将grpc的接口绑定到其他语言中也是可以使用的。由于Go语言都是基于源码进行的，在其他语言中需要下载protobuf的工具包，帮助将proto的接口转换为对应语言的接口。
grpc使用
copymaster
11-05 612
使用grpc和protobuf实现rpc通信的例子 创建工程 mkdir grpc_test cd grpc_test go mod init //使用github的grpc替换gp的grpc go mod edit -replace=google.golang.org/grpc=github.com/grpc/grpc-go@latest go mod edit -replace=gola...
最全1，2024年最新实现原理分析
2401_84904308的博客
05-13 669
RPC是的简称，中文叫远程过程调用，简单的说，就是调用远程方法和调用本地方法一样那么grpc就是由google开发的一个高性能、通用的开源RPC框架gRPC是一种现代开源高性能远程过程调用(RPC)框架，可在任何环境中运行。它可以高效地连接数据中心内的服务，并支持负载平衡、跟踪、健康检查和身份验证等插件功能。它适用于分布式计算的最后一英里，以连接设备、移动应用程序和浏览器到后端服务。公司已使用gRPC连接其环境中的多个服务，从连接少数服务到跨多种语言的数据中心内数百种服务。
gRPC快速入门
weixin_33713503的博客
12-18 447
gRPC快速入门gRPC快速入门（一）——Protobuf简介https://blog.51cto.com/9291927/2331980gRPC快速入门（二）——Protobuf序列化原理解析https://blog.51cto.com/9291927/2332264gRPC快速入门（三）——Protobuf应用示例https://blog.51cto.com/9291927/2332269gR...
grpc用法
weixin_45785496的博客
07-03 125
grpc命令用法 go 文件生成 下面这几种方式生成都可以： protoc --go_out=./go/ ./proto/helloworld.proto protoc --go_out=./go/ -I proto ./proto/helloworld.proto 指定目录 protoc -I protoc -I. -I$GOPATH/pkg/mod/github.com/grpc-ecosystem/grpc-gateway@v1.9.0/third_party/googleapis --grpc-ga
gRPC的使用
weixin_55959870的博客
02-21 1728
1.创建gRPC客户端 使用gRPC服务需要创建gRPC客户端来调用gRPC服务，gRPC 户端可以是控制台应用程序、Web应用程序或窗体应用程序。以控 制台应用程序作为gRPC客户端来调用gRPC服务的步骤如下: (1)创建gRPC客户端Web应用程序项目 (2)复制Protobuf文件 (3)添加gRPC客户端引用 (4)实现调用gRPC服务 (5)实现视图页面 (6)运行gRPC客户端 要保证文件一致 新添加控制器 2个视图的方法 直接在视图调用即可...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值