精华内容
下载资源
问答
  • java grpc框架

    2018-10-15 00:15:48
    java grpc框架,未来趋势,非常适合java开发者使用;下载后,解压,直接install即可用,非常方便
  • 目的是创建Blob二进制数据类型的概念证明,可以使用gRPC框架与任何服务一起发送或检索该Blob二进制数据类型。 必须使用Java 8 x64执行该项目。 它已经在Windows 10 x64上进行了测试,但也可以在其他平台上使用。 ...
  • gRPC - An RPC library and framework gRPC is a modern, open source, ...grpc-java Kotlin grpc-kotlin Go grpc-go NodeJS grpc-node WebJS grpc-web Dart grpc-dart .NET (pure C# impl.) grpc-dotnet
  • java使用gRPC的helloworld的demo实现https://blog.csdn.net/u013992365/article/details/81698531#%E6%96%B0%E5%BB%BA%E4%B8%80%E4%B8%AA%E6%99%AE%E9%80%9A%E7%9A%84maven%E9%A1%B9%E7%9B%AE grpc官方文档中文版...

    参考:

    1. java下使用gRPC的helloworld的demo实现https://blog.csdn.net/u013992365/article/details/81698531#%E6%96%B0%E5%BB%BA%E4%B8%80%E4%B8%AA%E6%99%AE%E9%80%9A%E7%9A%84maven%E9%A1%B9%E7%9B%AE
    2. grpc官方文档中文版 http://doc.oschina.net/grpc?t=58008
    3. 示例:https://github.com/grpc/grpc-java/tree/master/examples/src/main/java/io/grpc/examples

    具体实施步骤:

    1、新建一个普通的Maven项目:

    点击下一步,再点击Finsh。

    2、配置pom文件,导入grpc的依赖和插件

    全部的pom内容如下:

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.grpcprojects</groupId>
        <artifactId>grpcExercise3</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <properties>
            <grpc-version>1.20.0</grpc-version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>io.grpc</groupId>
                <artifactId>grpc-core</artifactId>
                <version>${grpc-version}</version>
            </dependency>
            <dependency>
                <groupId>io.grpc</groupId>
                <artifactId>grpc-netty-shaded</artifactId>
                <version>${grpc-version}</version>
            </dependency>
            <dependency>
                <groupId>io.grpc</groupId>
                <artifactId>grpc-protobuf</artifactId>
                <version>${grpc-version}</version>
            </dependency>
            <dependency>
                <groupId>io.grpc</groupId>
                <artifactId>grpc-stub</artifactId>
                <version>${grpc-version}</version>
            </dependency>
        </dependencies>
    
        <build>
            <extensions>
                <extension>
                    <groupId>kr.motd.maven</groupId>
                    <artifactId>os-maven-plugin</artifactId>
                    <version>1.5.0.Final</version>
                </extension>
            </extensions>
    
            <plugins>
                <plugin>
                    <groupId>org.xolstice.maven.plugins</groupId>
                    <artifactId>protobuf-maven-plugin</artifactId>
                    <version>0.5.1</version>
                    <configuration>
                        <protocArtifact>com.google.protobuf:protoc:3.7.1:exe:${os.detected.classifier}</protocArtifact>
                        <pluginId>grpc-java</pluginId>
                        <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.9.1:exe:${os.detected.classifier}</pluginArtifact>
                        <protoSourceRoot>src/main/proto</protoSourceRoot>
                    </configuration>
                    <executions>
                        <execution>
                            <goals>
                                <goal>compile</goal>
                                <goal>compile-custom</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.6.1</version>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    
    </project>

    添加好依赖之后的显示:

    添加之后选择右下键出现的import change,就能在Maven Projects中看到添加的依赖了。

    3、编写helloworld.proto文件

    在项目main目录下新建一个proto文件夹,再在此文件夹下创建一个helloworld.proto文件

    helloworld.proto(跟官网上的一样)中的代码如下:

    syntax = "proto3";
    
    option java_multiple_files = true;
    option java_package = "io.grpc.examples.helloworld";
    option java_outer_classname = "HelloWorldProto";
    option objc_class_prefix = "HLW";
    
    package helloworld;
    
    // The greeting service definition.
    service Greeter {
        // 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;
    }

    重要的地方来了,编译helloworld.proto文件,编译此文件有两种方法,第一种使用protoc.exe和protoc-gen-grpc-java插件进行编译。第二种方法是用刚才在项目里边添加的插件进行编译。下边分别进行说明:

    第一种:使用protoc.exe和protoc-gen-grpc-java插件进行编译

    下载protoc.exe 工具 , 下载地址:https://github.com/protocolbuffers/protobuf/releases

     下载protoc-gen-grpc 插件  , 下载地址: http://jcenter.bintray.com/io/grpc/protoc-gen-grpc-java/

    将protoc.exe和protoc-gen-grpc插件放到main目录中:

     

    在项目的terminal窗口中执行如下两条指令:

    执行完每条指令之后,窗口应该不会出现任何信息,在项目文件目录中会添加如下文件:

    第二种方法:用刚才在项目里边添加的插件进行编译

    在分割线下边

     

    4、添加客户端和服务端代码

    我是直接从官网上直接拿过来的代码,分别为HelloWorldClient.java和HelloWorldServer.java

    HelloWorldClient.java代码如下:

    /*
     * Copyright 2015 The gRPC Authors
     *
     * Licensed under the Apache License, Version 2.0 (the "License");
     * you may not use this file except in compliance with the License.
     * You may obtain a copy of the License at
     *
     *     http://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */
    
    package helloworld;
    
    import io.grpc.ManagedChannel;
    import io.grpc.ManagedChannelBuilder;
    import io.grpc.StatusRuntimeException;
    import io.grpc.examples.helloworld.GreeterGrpc;
    import io.grpc.examples.helloworld.HelloReply;
    import io.grpc.examples.helloworld.HelloRequest;
    
    import java.util.concurrent.TimeUnit;
    import java.util.logging.Level;
    import java.util.logging.Logger;
    
    /**
     * A simple client that requests a greeting from the {@link HelloWorldServer}.
     */
    public class HelloWorldClient {
      private static final Logger logger = Logger.getLogger(HelloWorldClient.class.getName());
    
      private final ManagedChannel channel;
      private final GreeterGrpc.GreeterBlockingStub blockingStub;
    
      /** Construct client connecting to HelloWorld server at {@code host:port}. */
      public HelloWorldClient(String host, int port) {
        this(ManagedChannelBuilder.forAddress(host, port)
            // Channels are secure by default (via SSL/TLS). For the example we disable TLS to avoid
            // needing certificates.
            .usePlaintext()
            .build());
      }
    
      /** Construct client for accessing HelloWorld server using the existing channel. */
      HelloWorldClient(ManagedChannel channel) {
        this.channel = channel;
        blockingStub = GreeterGrpc.newBlockingStub(channel);
      }
    
      public void shutdown() throws InterruptedException {
        channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
      }
    
      /** Say hello to server. */
      public void greet(String name) {
        logger.info("Will try to greet " + name + " ...");
        HelloRequest request = HelloRequest.newBuilder().setName(name).build();
        HelloReply response;
        try {
          response = blockingStub.sayHello(request);
        } catch (StatusRuntimeException e) {
          logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
          return;
        }
        logger.info("Greeting: " + response.getMessage());
      }
    
      /**
       * Greet server. If provided, the first element of {@code args} is the name to use in the
       * greeting.
       */
      public static void main(String[] args) throws Exception {
        HelloWorldClient client = new HelloWorldClient("localhost", 50051);
        try {
          /* Access a service running on the local machine on port 50051 */
          String user = "world";
          if (args.length > 0) {
            user = args[0]; /* Use the arg as the name to greet if provided */
          }
          client.greet(user);
        } finally {
          client.shutdown();
        }
      }
    }
    

    HelloWorldServer.java代码如下:

    /*
     * Copyright 2015 The gRPC Authors
     *
     * Licensed under the Apache License, Version 2.0 (the "License");
     * you may not use this file except in compliance with the License.
     * You may obtain a copy of the License at
     *
     *     http://www.apache.org/licenses/LICENSE-2.0
     *
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */
    
    package helloworld;
    
    import io.grpc.Server;
    import io.grpc.ServerBuilder;
    import io.grpc.examples.helloworld.GreeterGrpc;
    import io.grpc.examples.helloworld.HelloReply;
    import io.grpc.examples.helloworld.HelloRequest;
    import io.grpc.stub.StreamObserver;
    import java.io.IOException;
    import java.util.logging.Logger;
    
    /**
     * Server that manages startup/shutdown of a {@code Greeter} server.
     */
    public class HelloWorldServer {
      private static final Logger logger = Logger.getLogger(HelloWorldServer.class.getName());
    
      private Server server;
    
      private void start() throws IOException {
        /* The port on which the server should run */
        int port = 50051;
        server = ServerBuilder.forPort(port)
            .addService(new GreeterImpl())
            .build()
            .start();
        logger.info("Server started, listening on " + port);
        Runtime.getRuntime().addShutdownHook(new Thread() {
          @Override
          public void run() {
            // Use stderr here since the logger may have been reset by its JVM shutdown hook.
            System.err.println("*** shutting down gRPC server since JVM is shutting down");
            HelloWorldServer.this.stop();
            System.err.println("*** server shut down");
          }
        });
      }
    
      private void stop() {
        if (server != null) {
          server.shutdown();
        }
      }
    
      /**
       * Await termination on the main thread since the grpc library uses daemon threads.
       */
      private void blockUntilShutdown() throws InterruptedException {
        if (server != null) {
          server.awaitTermination();
        }
      }
    
      /**
       * Main launches the server from the command line.
       */
      public static void main(String[] args) throws IOException, InterruptedException {
        final HelloWorldServer server = new HelloWorldServer();
        server.start();
        server.blockUntilShutdown();
      }
    
      static class GreeterImpl extends GreeterGrpc.GreeterImplBase {
    
        @Override
        public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
          HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
          responseObserver.onNext(reply);
          responseObserver.onCompleted();
        }
      }
    }
    

     

    5、最终的文件结构

    6、执行服务端和客户端代码

    先执行HelloWorldServer.java,再HelloWorldClient.java,得如下运行结果,正面我们的gprc通信成功了。

    服务端显示如下:

     

    客户端显示如下:



    步骤1,2和上边完全相同,此处从步骤3的第二种方法开始说。

    第二种方法:用刚才在项目里边添加的插件进行编译。

    • 右击Maven.Projects\protobuf\protobuf:compile ,选择run,生成用于序列化的java文件。
    • 再右击Maven.Projects\protobuf\protobuf:compile-custom,选择run,生成用于rpc的java代码。

    执行完这两步,会产生的文件为:

    但是在执行这两步的过程中,控制台会出现报错的信息,但是在后边服务端和客户端运行的时候并没有报别的错误。

    哪位大佬能解决这个问题,麻烦请告知一下,多谢了。

    4、客户端和服务端的代码和上边写的一样

    5、项目文件目录如下:

    6、最后的运行结果(和上边的运行结果一样,并没有报错误)

    服务端的显示:

    客户端的显示:

     

    展开全文
  • gRPC框架学习:1、gRPC框架简介 文章目录gRPC框架学习:1、gRPC框架简介1. 前言2. gRPC简介3. Protocol Buffers简介4. 最后 1. 前言 之前我们学了很多的基于Go语言的包,从这里开始我们会接触并总结一些框架,目前...

    gRPC框架学习:1、gRPC框架简介


    1. 前言

    之前我们学了很多的基于Go语言的包,从这里开始我们会接触并总结一些框架,目前我们项目中接触并用到的一个框架是gRPC框架,简单理解可以当成gRPC是对rpc的一种扩展,存在多种语言版本,使得rpc服务和客户端可以跨多种语言进行交互。

    2. gRPC简介

    grpc官网:

    https://grpc.io/

    gRPC (gRPC Remote Procedure Calls) 是Google发起的一个开源远程过程调用 (Remote procedure call) 系统。该系统基于 HTTP/2 协议传输,使用Protocol Buffers 作为接口描述语言。

    gRPC是可以在任何环境中运行的现代开源高性能远程过程调用(RPC)框架。它可以通过可插拔的支持来有效地连接数据中心内和跨数据中心的服务,以实现负载平衡,跟踪,运行状况检查和身份验证。它也适用于分布式计算的最后一英里,以将设备,移动应用程序和浏览器连接到后端服务。

    其他功能:

    • 认证( authentication)
    • 双向流(bidirectional streaming)
    • 流控制(flow control)
    • 超时(timeouts)

    最常见的应用场景是:

    • 微服务框架下,多种语言服务之间的高效交互。
    • 将手机服务、浏览器连接至后台
    • 产生高效的客户端库

    在这里插入图片描述

    默认情况下,gRPC使用协议缓冲区(Protocol Buffers),这是谷歌成熟的用于序列化结构化数据的开源机制(尽管它可以用于其他数据格式,如JSON)。这里简单介绍一下它是如何工作的。

    3. Protocol Buffers简介

    Protocol Buffers(简称:ProtoBuf)是一种序列化数据结构的协议。对于透过管道(pipeline)或存储资料进行通信的程序开发上是很有用的。这个方法包含一个接口描述语言,描述一些数据结构,并提供程序工具根据这些描述产生代码,用于将这些数据结构产生或解析资料流。

    语言支持
    proto2提供一个程序产生器,支持C++、Java和Python。

    第三方实现支持JavaScript。

    proto3提供一个程序产生器,支持C++、Java (包含JavaNano)、Python、Go、Ruby、Objective-C和C#.从 3.0.0 Beta 2 版开始支持JavaScript。

    第三方实现支持Perl、PHP、Dart、Scala和Julia.

    https://developers.google.com/protocol-buffers/docs/overview

    4. 最后

    接下来我们先熟悉proto相关内容,然后对gRPC如何结合proto进行使用做总结。

    展开全文
  • Java 使用 Grpc 快速入门

    千次阅读 2019-07-25 23:22:43
    Grpc的原理 一个RPC框架必须有两个基础的组成部分:数据的序列化和进程数据通信的交互方式。 对于序列化gRPC采用了自家公司开源的Protobuf...使用Protocol Buffers 可以一次定义结构化的数据,然后可以使用特殊生...

    Grpc的原理

    一个RPC框架必须有两个基础的组成部分:数据的序列化和进程数据通信的交互方式。

    对于序列化gRPC采用了自家公司开源的Protobuf。什么是Protobuf?
    Google Protocol Buffer(简称 Protobuf) 是一种与语言无关,平台无关的可扩展机制,用于序列化结构化数据。
    使用Protocol Buffers 可以一次定义结构化的数据,然后可以使用特殊生成的源代码轻松地在各种数据流中使用各种语言编写和读取结构化数据。

    而关于进程间的通讯,无疑是Socket。Java方面gRPC同样使用了成熟的开源框架Netty。使用Netty Channel作为数据通道。传输协议使用了HTTP2。

    通过以上的分析,我们可以将一个完整的gRPC流程总结为以下几步:

    通过.proto文件定义传输的接口和消息体。
    通过protocol编译器生成server端和client端的stub程序。
    将请求封装成HTTP2的Stream。
    通过Channel作为数据通信通道使用Socket进行数据传输。
    

    使用Java 结合 Grpc 实现远程服务调用

    下面创建一个SpringBoot 多模块项目 与 Grpc 结合实现远程服务调用
    项目结构:

    SpringBoot-Grpc-Lib

    定义了两个.proto文件用于测试,并配置Gradle 插件,以便快速生成Java相关的实体类。
    user.proto

    syntax = "proto3";
    
    option java_package = "com.dashuai.learning.grpc.lib.proto";
    
    service User {
        rpc SaveUser (UserData) returns (UserResponse) {
        }
        rpc GetUser (UserRequest) returns (UserData) {
        }
    
    }
    message UserData {
        int32 id = 1;
        string name = 2;
        string sex = 3;
        int32 age = 4;
        string remark = 5;
    }
    message UserRequest {
        int32 id = 1;
    }
    message UserResponse {
        bool isSuccess = 1;
    }
    

    上述声明了两个RPC服务,分别是SaveUser()和GetUser(),顾名思义,保存一个用户和获取一个用户信息。
    该模块项目中,我配置了protobuf-gradle-plugin插件方便构建生成对应的Java类,build.gradle如下:

    apply plugin: 'com.google.protobuf'
    buildscript {
        repositories {
            mavenLocal()
            maven { url 'http://maven.aliyun.com/nexus/content/groups/public' }
        }
        dependencies {
            classpath 'com.google.protobuf:protobuf-gradle-plugin:0.8.1'
        }
    }
    
    protobuf {
        protoc {
            artifact = "com.google.protobuf:protoc:3.5.1"
        }
        plugins {
            grpc {
                artifact = 'io.grpc:protoc-gen-grpc-java:1.16.1'
            }
        }
        //配置生成输出目录
        generatedFilesBaseDir = "$projectDir/src"
        generateProtoTasks {
            all()*.plugins {
                grpc { outputSubDir = "java" }
            }
        }
    }
    sourceSets {
        main {
            proto {
                // In addition to the default 'src/main/proto'
                srcDir 'src/main/protobuf'
                srcDir 'src/main/protocolbuffers'
                include '**/*.protodevel'
            }
            java {
            }
        }
        test {
            proto {
                // In addition to the default 'src/test/proto'
                srcDir 'src/test/protocolbuffers'
            }
        }
    }
    

    配置无误后,点击右侧Tasks的GenerateProto生成对应的Java类

    上述配置的.proto对应生成的Java文件如下图:

    到此,服务的定义就完成了,下面分别对定义的服务进行实现。

    SpringBoot-Grpc-Server

    对应的服务端,实现服务所做业务,业务实现代码如下,使用一个全局Map存放用户信息,模拟数据库保存。

    @GrpcService(UserOuterClass.class)
    public class UserService extends UserGrpc.UserImplBase {
    
        private final static Logger log = LoggerFactory.getLogger(UserService.class);
    
        private Map<Integer, UserOuterClass.UserData> map = new HashMap<>();
    
        @Override
        public void saveUser(UserOuterClass.UserData request, StreamObserver<UserOuterClass.UserResponse> responseObserver) {
            try {
                map.put(request.getId(), request);
            } catch (Exception e) {
                log.error("保存失败了!msg:{}", e.getMessage());
            }
            UserOuterClass.UserResponse.Builder builder = UserOuterClass.UserResponse.newBuilder().setIsSuccess(true);
            responseObserver.onNext(builder.build());
            responseObserver.onCompleted();
    
        }
    
        @Override
        public void getUser(UserOuterClass.UserRequest request, StreamObserver<UserOuterClass.UserData> responseObserver) {
            responseObserver.onNext(map.get(request.getId()));
            responseObserver.onCompleted();
        }
    }
    

    SpringBoot-Grpc-Client

    对应的客户端,调用对应的服务

    @Service
    @Slf4j
    public class UserClientService {
        @GrpcClient("local-grpc-server")
        private Channel serverChannel;
    
        public boolean saveUser(UserOuterClass.UserData userData) {
            UserGrpc.UserBlockingStub userBlockingStub = UserGrpc.newBlockingStub(serverChannel);
            System.out.println(JSONParseUtils.object2JsonString(userData));
            UserOuterClass.UserResponse response = userBlockingStub.saveUser(userData);
            return response.getIsSuccess();
        }
    
        public UserOuterClass.UserData getUserData(int id) {
            UserGrpc.UserBlockingStub userBlockingStub = UserGrpc.newBlockingStub(serverChannel);
            UserOuterClass.UserData userData = userBlockingStub.getUser(UserOuterClass.UserRequest.newBuilder().setId(id).build());
            System.out.println(JSONParseUtils.object2JsonString(userData));
            return userData;
    
        }
    }
    

    使用两个API调用测试,将请求体转换为JSON格式,在使用JsonFormat转换成对应的对象进行服务的调用,
    这里我只是为了测试而这样做,实际使用可能有所区别。

       @PostMapping(value = "/user", produces = "application/json;charset=UTF-8")
        public boolean saveUser(HttpServletRequest request) throws IOException {
            String json = new String(IoUtils.toByteArray(request.getInputStream()), request.getCharacterEncoding());
            return userClientService.saveUser(ProtobufUtils.jsonToPf(json, UserOuterClass.UserData.newBuilder()));
        }
    
        @GetMapping(value = "/user/{id}")
        @ApiOperation(value = "获取User实例", notes = "获取用户信息", response = UserOuterClass.UserData.class)
        @ApiImplicitParam(name = "id", value = "用户id", required = true, dataType = "Integer")
        public ApiResult getUser(@PathVariable Integer id) throws InvalidProtocolBufferException {
            UserOuterClass.UserData userData = userClientService.getUserData(id);
            return ApiResult.prepare().success(ProtobufUtils.pfToJson(userData));
        }
    

    调用测试,录入一个用户信息:

    查询用户信息:

    到此,调用流程演示完毕!
    测试项目的源码已上传到Github:
    https://github.com/liaozihong/SpringBoot-Learning/tree/master/SpringBoot-Grpc

    参考链接:
    https://www.jianshu.com/p/30ef9b3780d9
    Protocol Buffers 3 简明教程
    https://juejin.im/entry/59bb30f76fb9a00a616f1b73

    展开全文
  • windows使用gRPC框架的详细说明

    千次阅读 2017-06-22 16:43:57
    用户写好 .proto 描述文件,之后使用 protoc 可以很容易编译成众多计算机语言(C++、Java、Python、C#、Golang 等)的接口代码。这些代码可以支持 gRPC,也可以不支持。   gRPC 是 Google 开源的 RPC 框...

    ProtoBuf 是一套接口描述语言(IDL)和相关工具集(主要是 protoc,基于 C++ 实现),类似 Apache 的 Thrift)。用户写好 .proto 描述文件,之后使用 protoc 可以很容易编译成众多计算机语言(C++、JavaPython、C#、Golang 等)的接口代码。这些代码可以支持 gRPC,也可以不支持。

     

    gRPC 是 Google 开源的 RPC 框架和库,已支持主流计算机语言。底层通信采用 gRPC 协议,比较适合互联网场景。gRPC 在设计上考虑了跟 ProtoBuf 的配合使用。在 gRPC 里客户端应用可以像调用本地对象一样直接调用另一台不同的机器上服务端应用的方法,使得您能够更容易地创建分布式应用和服务。与许多 RPC 系统类似,gRPC 也是基于以下理念:定义一个服务,指定其能够被远程调用的方法(包含参数和返回类型)。在服务端实现这个接口,并运行一个 gRPC 服务器来处理客户端调用。在客户端拥有一个存根能够像服务端一样的方法。

    两者分别解决的不同问题,可以配合使用,也可以分开。典型的配合使用场景是,写好 .proto 描述文件定义 RPC 的接口,然后用 protoc(带 gRPC 插件)基于 .proto 模板自动生成客户端和服务端的接口代码。

    关于protobuf库的编译生成,我之前的博客中已经具体说明过,这里我主要说一下gRPC框架在windows上的编译生成,关于gRPC的使用直接看官方文档就可以了,有中文版的:http://doc.oschina.net/grpc?t=58008#quickstart

    首先,下载安装MSYS2:http://www.msys2.org/

    (Download and run the installer - "x86_64" for 64-bit, "i686" for 32-bit Windows)             

    一路“下一步”就可以安装好MSYS2.

    然后运行msys2.exe脚本,执行如下命令:

    1、pacman -Syu       

    2、执行完后,关闭终端,重新打开终端执行:pacman -Su

    3、pacman -S git

    4、pacman -S mingw-w64-i686-grpc

    5、panman -S mingw-w64-i686-qt5

    6、pacman -S mingw-w64-i686-qt-creator

    之后就可以在安装的qt creator中添加在msys2/mingw32/lib中的grpc静态库和protobuf静态库!!!然后自己根据官网编写简单的c++工程进行测试,只要你库添加的没问题,测试可以通过。

    有任何问题可以评论区提问。

    展开全文
  • gRPC 是一个高性能、通用的开源RPC框架,其由 Google 主要面向移动应用开发并基于HTTP/2 协议标准而设计,基于 ProtoBuf(Protocol Buffers) 序列化协议开发,且支持java、C++、C#等众多开发语言。 本文根据csdn博主...
  • gRPC框架使用

    千次阅读 2019-06-10 16:02:11
    gRPC使用protobuf格式数据传输;至于什么是protuf,怎样使用,参见:http://idoubi.cc/2017/12/02/protobuf%E5%BF%AB%E9%80%9F%E4%B8%8A%E6%89%8B%E6%8C%87%E5%8D%97/ 使用protobuf最好在goland上安装protobuf插件...
  • grpc 框架

    2019-10-10 11:52:56
    gRPC 是一款高性能、开源的 RPC 框架,产自 Google,基于 ProtoBuf 序列化协议进行开发,支持多种语言(Golang、Python、Java等) gRPC 对 HTTP/2 协议的支持使其在 Android、IOS 等客户端后端服务的...
  • Python中gRPC框架使用发布时间:2020-06-19 14:24:48来源:亿速云阅读:134作者:元一简介gRPC 是一个高性能、开源和通用的 RPC 框架,面向移动和 HTTP/2 设计。目前提供 C、Java 和 Go 语言版本,分别是:grpc, ...
  • gRPC框架的Spring Boot Starter模块,特点:使用 Spring Boot 的应用进行自动配置,内嵌 gRPC server。支持 Spring Cloud(可以通过 Spring Cloud 进行服务注册并且获取 gRPC server 的信息)。支持 Spring Sleuth ...
  • 具体使用maven 依赖插件proto文件common(通过插件生成的java类和gRPC接口)gRPC服务端gRPC客户端 gRPC gRPC 是一个高性能、开源和通用的 RPC 框架,面向移动和 HTTP/2 设计。目前提供 C、Java 和 Go 语言版本,分别...
  • gRPC框架学习:5、 go+gRPC+proto详细使用实例 文章目录gRPC框架学习:5、 go+gRPC+proto详细使用实例1. 前言2. 完成proto文件3. 下载安装proto编译器及go相关插件4. 编译proto文件生成go相关文件5. 使用框架代码时...
  • Angular gRPC框架。 特征 双向绑定友好的protobuf消息实现(而不是原始google-protobuf中类似Java的setter / getter) 客户端服务连接到Angular的依赖项注入 打字稿一流的支持 rxjs一流的支持 拦截器 记录器 支持...
  • grpc框架分析之sprinboot整合grpc

    千次阅读 2019-04-30 09:49:33
    gRPC简介: gRPC 一开始由 google 开发,是一款语言中立...目前提供 C、Java 和 Go 语言版本,分别是:grpc, grpc-java, grpc-go. 其中 C 版本支持 C, C++, Node.js, Python, Ruby, Objective-C, PHP 和 C# 支持。 ...
  • JAVA使用gRPC

    2021-01-25 12:48:48
    gRPC是由google推出的高性能的RPC框架,基于http2和protobuf,下面使用如下java示例带大家初步认识gRPC。 一、引入依赖 <dependencies> <dependency> <groupId>io.grpc</groupId> <...
  • grpc-spring-boot-starter:用于gRPC框架的Spring Boot启动器模块
  • gRPC框架学习 (一)

    2021-03-25 21:24:55
    目前提供 C、Java 和 Go 语言版本,分别是:grpc, grpc-java, grpc-go. 其中 C 版本支持 C, C++, Node.js, Python, Ruby, Objective-C, PHP 和 C# 支持. gRPC代码仓库地址:https://github.com/grpc/grpc gRPC 官方...
  • gRPC 框架入门--(一)

    千次阅读 2019-07-23 10:44:07
    以下介绍如何安装grpc框架,编译grpc文件,以及在实际使用过程中碰到的坑。虽然一下示例在golang下实现的,但是grpc同时也支持java,c++等语言。 1.下载代码包:$ go get google.golang.org/grpc(需要翻墙) 还要...
  • java和python使用grpc交互

    千次阅读 2018-09-13 18:37:20
    本文实现Java和Python之间通过grpc交互,只使用最基本的单项rpc。 grpc教程:https://doc.oschina.net/grpc?t=58009 https://grpc.io/docs/ 一、Java实现grpc 使用idea新建maven项目,项目目录如下 项目的pom...
  • javagRPC实战》系列的开篇,掌握如何用proto文件生成java代码
  • 目前提供 C、Java 和 Go 语言版本,分别是:grpc, grpc-java, grpc-go. 其中 C 版本支持 C, C++, Node.js, Python, Ruby, Objective-C, PHP 和 C# 支持。 官方网站是: http://www.grpc.io/ 其中
  • 1. 简介 RPC(remote procedure call 远程过程调用)框架实际是提供了一套机制,使得应用程序...gRPC(google RPC)是一个高性能、开源和通用的 RPC 框架,面向移动和 HTTP/2 设计。目前提供 C、Java 和 Go 语言版本...
  • go语言gRPC框架实战解析

    千次阅读 2020-02-17 22:16:30
    前言: 这段时间一直研究grpc,记录如下: 1 grpc中的要点: 1.1 grpc 是什么? grpc是一个服务器,用于定义服务,指定方法,客户端可以通过他直接...proto buffer 称为协议缓冲区,用于定义结构化数据,并使用编译...
  • 概述 本文将会介绍两部分内容: ...为了能生成针对javagrpc客户端和服务端代码(官方叫stub),需要下载一些java包和grpc编译器以及一些gradle 插件 java依赖包 compile ‘io.grpc:grpc-netty:1.4.0
  • 开源RPC选型之sofa-rpc、brpc-javagRPC-java之间的那些事 文章目录开源RPC选型之sofa-rpc、brpc-javagRPC-java之间的那些事前言选型分析一、选型的侧重点二、功能对比三、优缺点对比性能分析环境测试数据对比与...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,241
精华内容 3,696
热门标签
关键字:

java使用grpc框架

java 订阅