2020-02-06 gRPC从入门到破产（1）最简单的HelloWorld

用惯了Spring全家桶，偶尔也尝试一下小清新的gRPC吧
为啥叫“从入门到破产”呢？因为中文输入法打“gRPC”出来的第一个就是“个人破产”，咱也总不能干啥都“从入门到入土”，“从入门到放弃”吧，偶尔也来点别的，哈哈。

本文已经与（2）整合后发在了我的个人网站，欢迎访问：http://www.wendev.site/article/25

一些废话

做完个人网站之后就一直处于非常颓废的状态，而最近总算找到要学的新东西了——gRPC！

为什么要学gRPC？还不是因为闲得都要发霉了，急需补充新知识啊，而且我一直觉得gRPC比Dubbo“小清新”多了，非常想找个机会一探究竟。

其实是最近要做一个比较大的项目，涉及到Python和Java混编的问题，为了解决这个问题，所以需要一个可以跨语言的RPC框架。本来想用性能更高的Thrift，但是这东西的参考资料实在太少了，所以选择了资料更多的gRPC。而且gRPC是Google开发的，大厂出品值得信赖啊。

Refrence

开始！

pom.xml

建一个Maven工程，并且引入以下依赖和插件：

<?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>site.wendev</groupId>
    <artifactId>grpc-helloworld</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/io.grpc/grpc-all -->
        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-all</artifactId>
            <version>1.27.0</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/javax.annotation/javax.annotation-api -->
        <dependency>
            <groupId>javax.annotation</groupId>
            <artifactId>javax.annotation-api</artifactId>
            <version>1.3.2</version>
        </dependency>
    </dependencies>

    <build>
        <extensions>
            <extension>
                <!-- https://mvnrepository.com/artifact/kr.motd.maven/os-maven-plugin -->
                <groupId>kr.motd.maven</groupId>
                <artifactId>os-maven-plugin</artifactId>
                <version>1.6.2</version>
            </extension>
        </extensions>
        <plugins>
            <plugin>
                <groupId>org.xolstice.maven.plugins</groupId>
                <artifactId>protobuf-maven-plugin</artifactId>
                <version>0.6.1</version>
                <configuration>
                    <protocArtifact>com.google.protobuf:protoc:3.11.3:exe:${os.detected.classifier}</protocArtifact>
                    <pluginId>grpc-java</pluginId>
                    <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.27.0:exe:${os.detected.classifier}</pluginArtifact>
                    <protocExecutable>/Users/jiangwen/tools/protoc-3.11.3/bin/protoc</protocExecutable>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>compile-custom</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

不需要Spring Initializr了，莫名感觉非常爽

proto文件的编写与代码生成

gRPC使用HTTP2作为通信协议，使用Google开源的protobuf作为序列化和反序列化协议，所以需要编写.proto文件，定义服务和其他相关信息：

hello_world.proto

syntax = "proto3";

option java_package = "site.wendev.grpc";
option java_outer_classname = "HelloWorldProto";

package helloworld;

service HelloWorld {
    rpc SayHello (HelloRequest) returns (HelloReply) {}
}

message HelloRequest {
    string name = 1;
}

message HelloReply {
    string message = 1;
}

简单来说，这段代码定义了一个发送一条信息的服务，并且定义了请求信息——包含name参数和响应信息——包含message参数。

然后使用Maven插件生成代码：

这两个插件都需要使用。

生成的文件如下，这两个文件里包含了我们需要的一些东西：

接着把它们放到项目里，就可以使用了：

服务端与客户端

这个因为太复杂，就照搬官方github仓库里的了。因为我的类名与官方的不一样，所以稍微改了改：

服务端（HelloWorldServer.java）：

package site.wendev.grpc;

import io.grpc.Server;
import io.grpc.ServerBuilder;
import io.grpc.stub.StreamObserver;

import java.io.IOException;
import java.util.logging.Logger;

public class HelloWorldServer {
    public static final Logger logger = Logger.getLogger(HelloWorldServer.class.getName());
    private Server server;

    private void start() throws IOException {
        int port = 50051;
        server = ServerBuilder.forPort(port)
                .addService(new GreeterImpl())
                .build()
                .start();
        logger.info("Server started, listening on " + port);
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            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();
        }
    }

    private void blockUntilShutdown() throws InterruptedException {
        if (server != null) {
            server.awaitTermination();
        }
    }

    public static void main(String[] args) throws IOException, InterruptedException {
        final HelloWorldServer server = new HelloWorldServer();
        server.start();
        server.blockUntilShutdown();
    }

    static class GreeterImpl extends HelloWorldGrpc.HelloWorldImplBase {

        @Override
        public void sayHello(HelloWorldProto.HelloRequest req, StreamObserver<HelloWorldProto.HelloReply> responseObserver) {
            HelloWorldProto.HelloReply reply = HelloWorldProto.HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
            responseObserver.onNext(reply);
            responseObserver.onCompleted();
        }
    }
}

客户端（HelloWorldClient.java）：

package site.wendev.grpc;

import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.StatusRuntimeException;

import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;

public class HelloWorldClient {
    private static final Logger logger = Logger.getLogger(HelloWorldClient.class.getName());

    private final ManagedChannel channel;
    private final HelloWorldGrpc.HelloWorldBlockingStub blockingStub;

    public HelloWorldClient(String host, int port) {
        this(ManagedChannelBuilder.forAddress(host, port)
                .usePlaintext()
                .build());
    }

    HelloWorldClient(ManagedChannel channel) {
        this.channel = channel;
        blockingStub = HelloWorldGrpc.newBlockingStub(channel);
    }

    public void shutdown() throws InterruptedException {
        channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
    }

    public void greet(String name) {
        logger.info("client request ==============" + name + " ...");
        HelloWorldProto.HelloRequest request = HelloWorldProto.HelloRequest.newBuilder().setName(name).build();
        HelloWorldProto.HelloReply response;
        try {
            response = blockingStub.sayHello(request);
        } catch (StatusRuntimeException e) {
            logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
            return;
        }
        logger.info("response: ===============" + response.getMessage());
    }

    public static void main(String[] args) throws Exception {
        HelloWorldClient client = new HelloWorldClient("localhost", 50051);
        try {
            String user = "world===============";
            if (args.length > 0) {
                user = args[0];
            }
            client.greet(user);
        } finally {
            client.shutdown();
        }
    }
}

运行

与Spring Cloud一样，需要先启动服务端（服务提供者），再启动客户端（服务消费者）。

启动服务端：

启动客户端：

客户端在启动时会向服务端发送请求（这个请求在greet方法里定义了），而客户端得到响应后，就立刻关闭了。

踩坑记录

这次的两个坑都是缺依赖，没有其他的什么坑。

坑1:使用Maven插件生成代码失败

在生成客户端的代码时，报了这么一个错误：

Could not transfer artifact io.grpc:protoc-gen-grpc-java:exe:${os.detected.classifier}:1.27.0 from/to alimaven (http://maven.aliyun.com/nexus/content/groups/public/): TransferFailedException

多番排查无果后，发现是缺了一个依赖（在build节点下）：

        <extensions>
            <extension>
                <!-- https://mvnrepository.com/artifact/kr.motd.maven/os-maven-plugin -->
                <groupId>kr.motd.maven</groupId>
                <artifactId>os-maven-plugin</artifactId>
                <version>1.6.2</version>
            </extension>
        </extensions>

加上这个依赖，就可以成功生成了。

坑2:Error:(23, 18) java: 找不到符号 符号: 类 Generated 位置: 程序包javax.annotation.Generated

这个错误发生在自动生成的代码中。

查了一下，这个其实也是缺少依赖导致的，加上它就好了：

<!-- https://mvnrepository.com/artifact/javax.annotation/javax.annotation-api -->
        <dependency>
            <groupId>javax.annotation</groupId>
            <artifactId>javax.annotation-api</artifactId>
            <version>1.3.2</version>
        </dependency>
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • grpc应用详解与实例剖析
    gRPC 是一个高性能、通用的开源RPC框架，基于HTTP/2协议标准和Protobuf序列化协议开发，支持众多的...
    小波同学阅读 19,573评论 6赞 19
  • google grpc 简介及官网的快速入门
    GRPC是基于protocol buffers3.0协议的. 本文将向您介绍gRPC和protocol buffe...
    二月_春风阅读 18,037评论 2赞 28
  • grpc应用详解
    原文出处：gRPC gRPC分享 概述 gRPC 一开始由 google 开发，是一款语言中立、平台中立、开源的远...
    小波同学阅读 7,325评论 0赞 18
  • gRPC
    1.简介 在gRPC中，客户端应用程序可以直接调用不同计算机上的服务器应用程序上的方法，就像它是本地对象一样，使您...
    第八共同体阅读 1,939评论 0赞 6
  • 108
    鸴鸣阅读 319评论 3赞 9