gRPC的原理和实践

最新推荐文章于 2025-03-26 13:54:13 发布
最新推荐文章于 2025-03-26 13:54:13 发布
阅读量1.4k 收藏 2
点赞数 1
分类专栏： 框架和中间件 文章标签： rpc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/henji318/article/details/131963573
版权

一、gRPC理论

1.概述

  1. RPC 全称 (Remote Procedure Call)，远程过程调用，指的是一台计算机通过网络请求另一台计算机的上服务，从而不需要了解底层网络细节，RPC 是构建在已经存在的协议（TCP/IP，HTTP 等）之上的，RPC 采用的是客户端，服务器模式。
  2. gRPC 是云原生计算基金会（CNCF）项目，gRPC 一开始由 google 开发，是一款语言中立、平台中立的服务间通信框架，使用 gRPC 可以使得客户端像调用本地方法一样，调用远程主机提供的服务。可以在任何地方运行，它使客户端和服务器应用程序能够透明地进行通信，并使构建连接系统变得更加容易。
  3. gRPC 目前最新版本是 v1.22.0。

2.特性

  1. gRPC 基于服务的思想：定义一个服务，描述这个服务的方法以及入参出参，服务器端有这个服务的具体实现，客户端保有一个存根，提供与服务端相同的服务。

  2. gRPC 默认采用 protocol buffer 作为 IDL (Interface Description Lanage) 接口描述语言，服务之间通信的数据序列化和反序列化也是基于 protocol buffer 的，因为 protocol buffer 的特殊性，所以 gRPC 框架是跨语言的通信框架（与编程语言无关性），也就是说用 Java 开发的基于 gRPC 的服务，可以用 GoLang 编程语言调用。

  3. gRPC 同时支持同步调用和异步调用，同步 RPC 调用时会一直阻塞直到服务端处理完成返回结果， 异步 RPC 是客户端调用服务端时不等待服务段处理完成返回，而是服务端处理完成后主动回调客户端告诉客户端处理完成。

  4. gRPC 是基于 http2 协议实现的，http2 协议提供了很多新的特性，并且在性能上也比 http1 提搞了许多，所以 gRPC 的性能是非常好的。

  5. gRPC 并没有直接实现负载均衡和服务发现的功能，但是已经提供了自己的设计思路。已经为命名解析和负载均衡提供了接口。

  6. 基于 http2 协议的特性：gRPC 允许定义如下四类服务方法：

    • 单项 RPC：客户端发送一次请求，等待服务端响应结构，会话结束，就像一次普通的函数调用这样简单

    • 服务端流式 RPC：客户端发起一起请求，服务端会返回一个流，客户端会从流中读取一系列消息，直到没有结果为止

    • 客户端流式 RPC：客户端提供一个数据流并写入消息发给服务端，一旦客户端发送完毕，就等待服务器读取这些消息并返回应答

    • 双向流式 RPC：客户端和服务端都一个数据流，都可以通过各自的流进行读写数据，这两个流是相互独立的，客户端和服务端都可以按其希望的任意顺序独写

3.使用场景

  1. 低延迟、高扩展的分布式系统。
  2. 与云服务通信。
  3. 设计一个需要准确，高效且与语言无关的新协议。
  4. 分层设计，以实现扩展，例如：身份验证，负载平衡，日志记录和监控等。

4.优点和缺点总结

gRPC 优点

  1. protobuf是二进制消息，性能好/效率高（空间和时间效率都很不错）。
  2. 通过在服务器和客户端之间共享 .proto 文件，可以端到端生成消息和客户端代码。 节约开发时间。并且有严格的规范。
  3. 基于HTTP/2，与 HTTP 1.x 相比，HTTP/2 具有巨大性能优势。
  4. 支持流式处理。
  5. 截止时间/超时和取消，gRPC 允许客户端指定其愿意等待 RPC 完成的时间期限。

gRPC 缺点

  1. 浏览器支持受限，无法通过浏览器直接调用gRPC服务。可以通过gRPC-web来做，但并不支持所有 gRPC 功能。 不支持客户端和双向流式传输，并且对服务器流式传输的支持有限。
  2. 默认情况下，gRPC 消息使用 Protobuf 进行编码。 尽管 Protobuf 可以高效地发送和接收，但其二进制格式人工不可读。
  3. gRPC尚未提供连接池，需要自行实现。
  4. 尚未提供“服务发现”、“负载均衡”机制。

5.原理

todo

二、gRPC实践

1.protocol buffer语法

proto buffer是一种轻便高效的结构化数据存储格式，可以用于结构化数据序列化。适合做数据存储或 RPC 数据交换格式。可用于通讯协议、数据存储等领域的语言无关、平台无关、可扩展的序列化结构数据格式。gRPC默认使用 protobuf 作为IDL来定义数据结构和服务。 可以定义数据结构，也可以定义rpc 接口。 然后用proto编译器生成对应语言的框架代码。

proto buffer定义：

user.proto

syntax = "proto3";

import "google/protobuf/any.proto";

//package user;
option go_package = "protos_golang/user";

message User {
  int32 id = 1;
  string name = 2;
  uint32 age = 3;
  enum Flag {
    NORMAL = 0;
    VIP = 1;
    SVIP = 2;
  }
  repeated int32 friends_ids = 5;
  reserved 6, 7, 8;
  message Command {
      int32 id = 1;
      oneof cmd_value {
         string name = 2;
         int32 age = 3;
      }
  }
  Command cmd = 9;
  map<int32, string> tags = 10;
  google.protobuf.Any details = 11;
}

具体参数含义参考文章：gRPC 特性、原理、实践、生态：https://zhuanlan.zhihu.com/p/403336804

2.gRPC的简单实现

1.添加POM依赖

//gRPC依赖包
<dependency>
    <groupId>io.grpc</groupId>
    <artifactId>grpc-all</artifactId>
    <version>1.12.0</version>
</dependency>

...
//proto buffer编译器maven插件
<build>
        <extensions>
            <extension>
                <groupId>kr.motd.maven</groupId>
                <artifactId>os-maven-plugin</artifactId>
                <version>1.4.1.Final</version>
            </extension>
        </extensions>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.xolstice.maven.plugins</groupId>
                <artifactId>protobuf-maven-plugin</artifactId>
                <version>0.5.0</version>
                <configuration>
                    <pluginId>grpc-java</pluginId>
                    <protocArtifact>com.google.protobuf:protoc:3.0.2:exe:${os.detected.classifier}</protocArtifact>
                    <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.2.0:exe:${os.detected.classifier}</pluginArtifact>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>compile-custom</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

2.编写proto buffer文件

syntax = "proto3"; // 协议版本

// 选项配置
option java_package = "com.yangnk.springboottestexample.grpcExample.api";
option java_outer_classname = "RPCDateServiceApi";
option java_multiple_files = true;

// 定义包名
package com.yangnk.springboottestexample.grpcExample;

// 服务接口.定义请求参数和相应结果
service RPCDateService {
    rpc getDate (RPCDateRequest) returns (RPCDateResponse) {
    }
}

// 定义请求体
message RPCDateRequest {
    string userName = 1;
}

// 定义相应内容
message RPCDateResponse {
    string serverDate = 1;
}

其中option java_package参数规定了proto buffer编译后java代码位置，编译会在target目录下生成，后续需要自己移动到对于的src/main目录中。

image-20230727143715719

在maven的插件选项中，第一步生成的bean实例，第二步生成服务接口。

image-20230727145918284

3.服务端实现

编写接口实现逻辑

import com.yangnk.springboottestexample.grpcExample.api.RPCDateRequest;
import com.yangnk.springboottestexample.grpcExample.api.RPCDateResponse;
import com.yangnk.springboottestexample.grpcExample.api.RPCDateServiceGrpc;
import io.grpc.stub.StreamObserver;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

// RPCDateServiceGrpc.RPCDateServiceImplBase 这个就是接口.
// RPCDateServiceImpl 我们需要继承他的,实现方法回调
public class RPCDateServiceImpl extends RPCDateServiceGrpc.RPCDateServiceImplBase {
    @Override
    public void getDate(RPCDateRequest request, StreamObserver<RPCDateResponse> responseObserver) {
        // 请求结果,我们定义的
        RPCDateResponse rpcDateResponse = null;
        String userName = request.getUserName();
        String response = String.format("你好: %s, 今天是%s.", userName, LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
        try {
            // 定义响应,是一个builder构造器.
            rpcDateResponse = RPCDateResponse
                    .newBuilder()
                    .setServerDate(response)
                    .build();
        } catch (Exception e) {
            responseObserver.onError(e);
        } finally {
            // 这种写法是observer,异步写法,老外喜欢用这个框架.
            responseObserver.onNext(rpcDateResponse);
        }
        responseObserver.onCompleted();
    }

编写服务端启动类

import io.grpc.Server;
import io.grpc.ServerBuilder;

public class GRPCServer {
    private static final int port = 9999;

    public static void main(String[] args) throws Exception {
        // 设置service接口.
        Server server = ServerBuilder.
                forPort(port)
                .addService(new RPCDateServiceImpl())
                .build().start();
        System.out.println(String.format("GRpc服务端启动成功, 端口号: %d.", port));
        server.awaitTermination();
    }
}

4.客户端实现

import com.yangnk.springboottestexample.grpcExample.api.RPCDateRequest;
import com.yangnk.springboottestexample.grpcExample.api.RPCDateResponse;
import com.yangnk.springboottestexample.grpcExample.api.RPCDateServiceGrpc;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;

public class GRPCClient {
    private static final String host = "localhost";
    private static final int serverPort = 9999;

    public static void main(String[] args) throws Exception {
        // 1. 拿到一个通信的channel
        ManagedChannel managedChannel = ManagedChannelBuilder.forAddress(host, serverPort).usePlaintext().build();
        try {
            // 2.拿到道理对象
            RPCDateServiceGrpc.RPCDateServiceBlockingStub rpcDateService = RPCDateServiceGrpc.newBlockingStub(managedChannel);
            RPCDateRequest rpcDateRequest = RPCDateRequest
                    .newBuilder()
                    .setUserName("yangnk")
                    .build();
            // 3. 请求
            RPCDateResponse rpcDateResponse = rpcDateService.getDate(rpcDateRequest);
            // 4. 输出结果
            System.out.println(rpcDateResponse.getServerDate());
        } finally {
            // 5.关闭channel, 释放资源.
            managedChannel.shutdown();
        }
    }
}

5.结果验证

image-20230727152507703

3。gRPC结合springboot的实现

说明

为gRPC结合springboot，使用的是开源库net.devh:grpc-server-spring-boot-starter，在调用其他gRPC服务时用的是net.devh:grpc-client-spring-boot-starter。具体使用方法如下：

  • 在 spring boot 应用中，通过 @GrpcService 自动配置并运行一个嵌入式的 gRPC 服务。
  • 使用 @GrpcClient 自动创建和管理您的 gRPC Channels 和 stubs

具体创建流程如下：

1.创建父工程

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.5.6</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

<modelVersion>4.0.0</modelVersion>
<groupId>com.yangnk</groupId>
<artifactId>gRPCDemo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>pom</packaging>
<description>Demo project for Spring Boot</description>
<properties>
    <java.version>1.8</java.version>
</properties>

<modules>
    <module>GRPCApi</module>
    <module>GRPCServer</module>
    <module>GRPCClient</module>
</modules>

指定该项目的POM文件中<packaging>pom</packaging>即为父工程。

2.创建API子工程

在src/proto目录下出创建helloworld.proto文件，同上面 ：grpc的简单实现-编写proto buffer文件 部分生成对于的bean文件和接口文件。

syntax = "proto3";

option java_multiple_files = true;
option java_package = "com.yangnk.grpcapi.api";
option java_outer_classname = "HelloWorldProto";

// The greeting service definition.
service Simple {
    // Sends a greeting
    rpc SayHello (HelloRequest) returns (HelloReply) {
    }
}

// The request message containing the user's name.
message HelloRequest {
    string name = 1;
}

// The response message containing the greetings
message HelloReply {
    string message = 1;
}

image-20230727154152660

3.创建服务端子工程

引入pom文件

...
<!--父工程依赖位置-->
<parent>
    <groupId>com.yangnk</groupId>
    <artifactId>GRPCDemo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</parent>
<groupId>com.yangnk</groupId>
<artifactId>GRPCServer</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>GRPCServer</name>
<description>Demo project for Spring Boot</description>
<properties>
    <java.version>1.8</java.version>
</properties>
<dependencies>
  
		<!--grpc服务端依赖包-->
    <dependency>
        <groupId>net.devh</groupId>
        <artifactId>grpc-server-spring-boot-starter</artifactId>
        <version>2.12.0.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>com.yangnk</groupId>
        <artifactId>GRPCApi</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </dependency>

    <!--Lombok引入-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
  ...

创建配置文件 application.yaml

spring:
  application:
    name: spring-boot-grpc-server
# gRPC有关的配置，这里只需要配置服务端口号
grpc:
  server:
    port: 9898
server:
  port: 8080

配置接口实现类

import com.yangnk.grpcapi.api.HelloReply;
import com.yangnk.grpcapi.api.HelloRequest;
import com.yangnk.grpcapi.api.SimpleGrpc;
import io.grpc.stub.StreamObserver;
import net.devh.boot.grpc.server.service.GrpcService;
import java.util.Date;

@GrpcService
public class GrpcServerService extends SimpleGrpc.SimpleImplBase {

    @Override
    public void sayHello(HelloRequest request,
                         StreamObserver<HelloReply> responseObserver) {
        HelloReply reply = HelloReply.newBuilder().setMessage("你好， " + request.getName() + ", " + new Date()).build();
        responseObserver.onNext(reply);
        responseObserver.onCompleted();
    }
}

4.创建客户端子工程

    ...
		<parent>
        <groupId>com.yangnk</groupId>
        <artifactId>GRPCDemo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <groupId>com.yangnk</groupId>
    <artifactId>GRPCClient</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>GRPCClient</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>net.devh</groupId>
            <artifactId>grpc-client-spring-boot-starter</artifactId>
            <version>2.12.0.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>com.yangnk</groupId>
            <artifactId>GRPCApi</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

        <!--Lombok引入-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
...

配置文件application.yaml

server:
  port: 8088
spring:
  application:
    name: local-client

grpc:
  client:
    # gRPC配置的名字，GrpcClient注解会用到
    local-grpc-server:
      # gRPC服务端地址
      address: 'static://127.0.0.1:9898'
      enableKeepAlive: true
      keepAliveWithoutCalls: true
      negotiationType: plaintext

调用服务端接口

import com.yangnk.grpcapi.api.HelloReply;
import com.yangnk.grpcapi.api.HelloRequest;
import com.yangnk.grpcapi.api.SimpleGrpc;
import io.grpc.StatusRuntimeException;
import net.devh.boot.grpc.client.inject.GrpcClient;
import org.springframework.stereotype.Service;

@Service
public class GrpcClientService {

    @GrpcClient("local-grpc-server")
    private SimpleGrpc.SimpleBlockingStub simpleStub;

    public String sendMessage(final String name) {
        try {
            final HelloReply response = this.simpleStub.sayHello(HelloRequest.newBuilder().setName(name).build());
            return response.getMessage();
        } catch (final StatusRuntimeException e) {
            return "FAILED with " + e.getStatus().getCode().name();
        }
    }
}

三、总结

gRPC是一种基于CS模式的架构设计，解决了服务端和客户端编程语言或架构设计不一致但需要通信的问题，HTTP也是CS模式的架构设计，常用来和gRPC比较，相比于HTTP通信，gRPC具有以下特征：（1）gRPC可以自定义消息格式，HTTP的格式是固定的，可能存在性能不足的问题；（2）gRPC通过proto buffer进行数据交换，相比于json和XML，他的序列号和反序列号的效率都更高。

四、常用问题总结

TODO

  • 补充gRPC的原理。
  • 总结使用gRPC过程中的常见问题。

参考资料

  1. gRPC 官方文档中文版：https://doc.oschina.net/grpc?t=60134
  2. grpc 官方代码：https://github.com/grpc/grpc-java/tree/master/examples
  3. gRPC-Spring-Boot-Starter 文档：https://yidongnan.github.io/grpc-spring-boot-starter/zh-CN/
  4. 带你走入GRPC (Java版本)：https://juejin.cn/post/6844904115248562189#heading-6 （纯java编写）
  5. 3小时快速入门Java版gRPC系列（九）-使用spring boot集成grpc：https://zhuanlan.zhihu.com/p/434323358 （grpc+springboot的结合，主要参考文章）
  6. SpringBoot整合高性能微服务框架 gRPC：https://ost.51cto.com/posts/11223
  7. gRPC系列 ：RPC 框架原理是？gRPC 是什么？gRPC设计原则：https://developer.aliyun.com/article/886793
  8. gRPC 的特性和背后设计的原则（一）：https://learnku.com/articles/32912
AI系统gRPC原理与代码实战案例讲解
AI天才研究院
06-03 879
gRPC（Google Remote Procedure Call，Google远程过程调用）是一个高性能的开源RPC框架，主要用于构建分布式系统和微服务。gRPC本质上是一个跨平台、跨语言的RPC框架，支持多种语言，包括Go、Python、Java、C++等。gRPC的核心特点是：高性能、易于使用、语言无关、自动代码生成、协议自定义等。在gRPC中，服务定义是通过协议缓冲区（Protocol Buffer）文件来描述的。协议缓冲区文件包含了服务的接口、方法、消息等信息。
grpc通信原理_gRPC原理简析
weixin_39968266的博客
12-12 1818
gRPC原理简析gRPC是由谷歌提出并开发的RPC协议，gRPC提供了一套机制，使得应用程序之间可以进行通信。 降级开发者的使用门槛，屏蔽网络协议，调用对端的接口就像是调用本地的函数一样。而gRPC的核心组成部分则是protocol buffers和http2.0，以下将详细讨论：protocol buffers简介开发者可以使用 pb compiler 生成用于读写数据代码。多语言支持特性，轻松...
GRPC原理解析
08-13
NULL 博文链接：https://shift-alt-ctrl.iteye.com/blog/2292862
grpc介绍及使用
最新发布
m0_67790484的博客
03-26 1064
service是一个关键字，用于在.proto文件中定义一个服务接口。服务接口是一组远程过程调用（RPC）方法的集合，客户端可以通过这些方法与服务端进行通信。
gRPC 基本原理
Happy博客
01-28 1179
/第一行指定了正在使用 proto3 语法：若未指定编译器会使用 proto2。这个指定语法行必须是文件的非空非注释的第一个行。// 为每个 message 单独生成一个类文件//指定 .proto 文件包名，防止不同项目之间的命名冲突。在java中，包名称用作Java包。在 .pb文件 中定义好 service 后，通过借助 gRPC 的 protocol buffers 插件，生成 gRPC 服务端代码。
grpc原理及四种实现方式
热门推荐
Forward__的博客
08-20 1万+
文章目录1. 概述2. grpc3. 使用API4. 服务定义5. 同步与异步6. 一元 RPC7. 服务器流 RPC8. 客户流 RPC9. 双向流 RPC10. 截止日期/超时11. RPC 终止12. 取消 RPC 1. 概述 RPC（Remote Procedure Call）-远程过程调用，他是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。 RPC采用客户端/服务器模式。请求程序就是一个客户端，而服务提供程序就是一个服务器。首先，客户端调用进程发送一个有进程参数的调用信息
深入浅出：gRPC通信原理详解
weixin_53840353的博客
04-25 901
gRPC是一个开源的远程过程调用（RPC）系统，由谷歌主导开发。它基于HTTP/2协议传输，并使用Protocol Buffers作为接口描述语言。gRPC旨在提供一种透明的方式使得客户端在调用服务器上的方法时，就像是在调用本地对象一样。gRPC首先要求使用Protocol Buffers（protobuf）来定义服务接口和消息格式。Protobuf的定义文件（.proto）中包含了服务的RPC方法和传输消息的数据结构。这些定义被用来生成客户端和服务端代码。
gRPC：gRPC基础概念与原理
kkchenjj的博客
07-12 1909
首先，我们需要使用 Protocol Buffers 定义服务接口。创建一个名为协议缓冲区（Protocol Buffers）是Google开发的一种数据交换格式，它高效、简洁且自描述。Protocol Buffers非常适合用于网络通信和数据存储，可以将结构化数据序列化，使得数据可以存储在数据库中或通过网络进行传输。Protocol Buffers的数据描述语言（.proto文件）允许你定义数据结构，然后通过Protocol Buffers编译器生成代码，用于在各种语言中读写这些数据结构。
基于C++语言的gRPC框架实践教程设计源码
02-14
本项目是一个全面的C++语言gRPC框架实践教程设计源码，它为开发者提供了一套完整的工具和资源，通过本教程的学习，开发者将能够熟练掌握C++语言与gRPC框架的结合使用，为解决实际问题和开发高性能应用打下坚实的基础...
【Web框架】3.GRPC原理
lixiaonan0318的博客
03-27 1091
RPCRPC1. rpc协议rpc远程过程调用，是一套协议，基于这套协议规范来实现的框架都可以称为 rpc 框架，常见的 Dubbo、Thrift 和 gRPC。本地方法调用的形式：对于调用方来说，调用 rpc 方法和调用本地方法并没有明显区别。保存服务端地址信息请求编码：将客户端请求方法名、参数等打包，序列化发送请求到服务端（grpc用的是http2方式发送的）接收请求：包含要调用的方法名、参数、其他元数据，并解码调用本地方法：将请求中的参数传递给本地方法，并等待执行。
gRPC实现原理1
qq_22421145的博客
03-19 816
流控：功能上类似与tcp流控，这里的流控借助WINDOW_UPDATE帧实现，不仅能控制单个流的发送接受窗口，还能控制整个连接的安全：http2要求必须使用TLS1.2及以上用来确保传输安全，也就是常说的https。并在此基础上提出许多安全问题错误：定义了常见的错误类型......如果你想更加全面地了解http2，请阅读以下官方规范学习h2最好的办法是一边阅读规范，一边参考博客，一边动手抓包，一边编写代码，这样才可以有更深入的理解。
gRPC基础讲解
记录一位C++爱好者的笔记
09-28 3546
RPC 即远程过程调用协议（Remote Procedure Call Protocol），可以让我们像调用本地函数一样发起远程调用。RPC 凭借其强大的治理功能，成为解决分布式系统通信问题的一大利器。gRPC是一个现代的、高性能、开源的和的通用 RPC 框架（g就是谷歌的意思），基于 HTTP2 协议设计，序列化使用 PB(Protocol Buffer)，PB 是一种语言无关的高性能序列化框架，基于 HTTP2+PB 保证了的高性能。上面的图就是一个客户端远程连接一个服务器，调用它的函数。
grpc使用与原理
kullollo的博客
11-22 7620
grpc是一个高性能，开源通用的rpc框架，面向移动和http2设计，目前支持C, Java和go语言。本篇博客可以帮助初学者快速了解grpc，并使用grpc实现分布式。 目录介绍安装 介绍 官网上介绍了grpc的一些基本概念，其中最重要的是: grpc使用了protobuffer（协议缓冲）实现其分布式的功能。通过protobuffer定义传输消息的数据结构，以及访问该数据结构的访问类，网络中的节点得以传输消息，进而实现分布式功能。 与socket相比，grpc实现了网络传输功能的封装，因此不用向s..
深入理解grpc（二）：grpc原理
ta206的博客
10-30 4276
gRPC 建立在两个快速高效的协议之上，称为protocol buffer和 HTTP/2。protocol buffer是一种数据序列化协议，它是一种与语言无关、平台中立和可扩展的结构化数据序列化方法。序列化后，此协议会生成一个比普通 JSON 数据更小的二进制强类型数据。之后，这个序列化后的二进制数据会通过称为 HTTP/2 的二进制传输协议进行传输。HTTP/2 是互联网协议 HTTP 的下一个主要版本。
grpc内部原理
日积月累
12-29 1792
参考：https://cloud.tencent.com/developer/article/1416195 PRC服务的核心问题 一、服务注册 服务注册是指服务将服务代码注册到RPCSever中，RPCSever将业务对象指针进行保存到容器。 二、服务调用 在RPCClient远程调用业务代码时将调用的方法名、类型名一字符串的形式通过网络形式传输到服务端， 服务根据类型名和方法名调用...
学习gRPC - 1.工作原理是什么
叉叉敌的博客
02-06 600
什么是gRPC gRPC 已经成为实现需要大规模快速运行的分布式软件系统的一项重要技术。简而言之，gRPC 是一个 API 框架，它允许一个程序在互联网上的一个位置传递数据到另一个位置的另一个程序中的独特函数进行处理。 其他 API 框架(如 REST)通常使用基于文本的格式(如 JSON 或 XML)在客户机和服务器之间传递数据，而在 gRPC 下，数据是以二进制格式在客户机和服务器端...
GRPC框架原理分析
互联网架构师笔记
04-20 365
grpc 是 google 开源的一款高性能的 rpc 框架。github 上介绍如下：市面上的 rpc 框架数不胜数，包括 alibaba dubbo 和微博的 motan 等。grpc 能够在众多的框架中脱颖而出是跟其高性能是密切相关的。阅读 grpc 源码之前，我们不妨先了解一些 concepts，github 上也有一些 concepts 介绍。
Grpc实践
weixin_41431016的博客
11-13 968
实践参考文档 官方grpc小例子分析 目录结构 helloword.proto client、server交互的接口定义文件，protoc命令会解析此文件生成对应的接口文件 syntax = "proto3"; option go_package = "google.golang.org/grpc/examples/helloworld/helloworld"; option java_multiple_files = true; option java_package = "io.grpc.examp
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

yangnk42

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值