宣告： CSDN原創投稿，未經許可，禁止任何形式的轉載。
作者：趙昌峻，碼農、全棧工程師，長期關注雲端計算、大資料、移動網際網路相關技術，從事IT行業十載，有5年的企業級應用開發經歷、3年的雲平臺（openstack）研發經歷，目前從事移動APP的研發，堅持每天快樂的程式設計。

什麼是gRPC？

在知乎上有這樣一個問題：誰能用通俗的語言解釋一下什麼是 RPC 框架？，各路大神講的都很到位，這裡我就不詳細解釋了，gRPC就是其中的一種RPC框架。

如上圖所示，在gRPC中，客戶端應用程式可以就像呼叫本地物件方法一樣直接呼叫不同伺服器上的應用程式方法，使您更容易建立分散式應用程式和服務。與許多RPC系統一樣，gRPC基於定義服務的思想，定義可以遠端呼叫的方法，包括方法的引數和返回型別。在伺服器端，伺服器實現此介面並執行一個gRPC伺服器來處理客戶端呼叫。在客戶端，客戶端有一個“存根stub”（簡稱為某些語言的客戶端），提供與伺服器相同的方法。所有的資料傳輸都使用protobuf。

gRPC服務的定義

syntax = "proto3";

option go_package = "user";
option java_package = "com.ylifegroup.protobuf";

enum PhoneType {
    HOME = 0;
    WORK = 1;
    OTHER = 2;
}

message ProtobufUser {
  int32 id = 1;
  string name = 2;
  message Phone{
  PhoneType phoneType = 1;
  string phoneNumber = 2;
  }
  repeated Phone phones = 3
 
;
}

message AddPhoneToUserRequest{
  int32 uid = 1;
  PhoneType phoneType = 2;
  string phoneNumber = 3;
}

message AddPhoneToUserResponse{
  bool result = 1;
}

service PhoneService {
  rpc addPhoneToUser(AddPhoneToUserRequest) returns (AddPhoneToUserResponse);
}

增加的內容很簡單，定義了一個關於電話本的服務PhoneBookService，服務包括一個把電話增加到指定聯絡人的方法addPhoneToUser，同時定義了方法的引數AddPhoneToUserRequest和返回值AddPhoneToUserResponse。

gRPC服務的伺服器端實現

為了方便我們後面講解微服務架構，從本節開始我們使用Java作為我們的開發語言。

我們的Demo將使用Gradle自動化構建工具，這裡不會深入講解Gradle的用法，建議沒有使用過Gradle的可以從官方網站開始：https://gradle.org

可以使用下面的命令生成Java專案的基本結構：

mkdir gRPCDemo
cd gRPCDemo
gradle init --type=java-library

初始化後，目錄結構如下所示：

└── gRPCDemo
    ├── build.gradle
    ├── gradle
    │   └── wrapper
    │       ├── gradle-wrapper.jar
    │       └── gradle-wrapper.properties
    ├── gradlew
    ├── gradlew.bat
    ├── settings.gradle
    └── src
        ├── main
        │   └── java
        │       └── Library.java
        └── test
            └── java
                └── LibraryTest.java

先刪除沒用的Library.java和LibraryTest.java。

然後修改配置檔案build.gradle，如下所示：

/*
 * This build file was auto generated by running the Gradle 'init' task
 * by 'ChangjunZhao' at '16-12-27 下午3:25' with Gradle 3.1
 *
 * This generated file contains a sample Java project to get you started.
 * For more details take a look at the Java Quickstart chapter in the Gradle
 * user guide available at https://docs.gradle.org/3.1/userguide/tutorial_java_projects.html
 */

// Apply the java plugin to add support for Java
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'com.google.protobuf'

repositories {
    // Use 'jcenter' for resolving your dependencies.
    // You can declare any Maven/Ivy/file repository here.
    jcenter()
}

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.google.protobuf:protobuf-gradle-plugin:0.8.0'
    }
}

sourceSets {
    main {
        java{
            srcDir 'gen/main/java'
            srcDir 'gen/main/grpc'
        }
        proto {
            srcDir 'src/main/proto'
        }
    }
}

jar {
    from {
        configurations.runtime.collect {
            it.isDirectory() ? it : zipTree(it)
        }
        configurations.compile.collect {
            it.isDirectory() ? it : zipTree(it)
        }
    }
    manifest {
        attributes 'Main-Class': 'com.ylifegroup.protobuf.server.GRpcServer'
    }
}

protobuf {
    protoc {
        artifact = "com.google.protobuf:protoc:3.1.0"
    }
    plugins {
        grpc {
            artifact = 'io.grpc:protoc-gen-grpc-java:1.0.3'
        }
    }
    generatedFilesBaseDir = "$projectDir/gen/"
    generateProtoTasks {
        all()*.plugins {
            grpc {}
        }
    }
}

dependencies {
    compile 'io.grpc:grpc-netty:1.0.3'
    compile 'io.grpc:grpc-protobuf:1.0.3'
    compile 'io.grpc:grpc-stub:1.0.3'
    // The production code uses the SLF4J logging API at compile time
    compile 'org.slf4j:slf4j-api:1.7.21'

    // Declare the dependency for your favourite test framework you want to use in your tests.
    // TestNG is also supported by the Gradle Test task. Just change the
    // testCompile dependency to testCompile 'org.testng:testng:6.8.1' and add
    // 'test.useTestNG()' to your build script.
    testCompile 'junit:junit:4.12'
}

eclipse {
  classpath {
    defaultOutputDir = file('build/eclipse/bin')
  }
}

clean {
    delete protobuf.generatedFilesBaseDir
}

我們使用了grpc官方提供的gradle外掛com.google.protobuf，它可是相當牛B，可以幫我們自動生成grpc相關的程式碼。

為了完成伺服器端的開發，增加了grpc相關的三個依賴：

io.grpc:grpc-netty:1.0.3
io.grpc:grpc-protobuf:1.0.3
io.grpc:grpc-stub:1.0.3

在protobuf的配置部分，我們使用grpc程式碼生成的外掛，以便自動幫我們生成grpc伺服器端的程式碼（介面），具體的實現還需要我們自己去搞定。

在原始檔配置部分sourceSets，我們指定了proto檔案的目錄src/main/proto，同時把protobuf自動生成程式碼所在兩個目錄(預設)gen/main/java,gen/main/grpc增加到Java的原始檔目錄，這樣在編譯的時候才會編譯這兩個目錄下的Java類。

OK，基本配置就這些，把上一節的gRPC服務定義檔案phonebook.proto放到我們專案的src/main/proto目錄（如果不存在自己手動建立）下，執行如下命令：

./gradlew build

gradle會幫你自動生了protobuf和grpc相關的檔案到如下目錄：

├── gen
│   └── main
│       ├── grpc
│       │   └── com
│       │       └── ylifegroup
│       │           └── protobuf
│       │               └── PhoneServiceGrpc.java
│       └── java
│           └── com
│               └── ylifegroup
│                   └── protobuf
│                       └── Phonebook.java

OK，剩下的工作大部分需要手動完成了，執行如下命令，生成Eclipse相關的配置檔案：

./gradlew eclipse

然後用Eclipse開啟gRPCDemo專案。

我們新建三個package:

com.ylifegroup.protobuf.service //用於放gRPC服務的實現類
com.ylifegroup.protobuf.server //用於放gRPC伺服器的實現類
com.ylifegroup.protobuf.client //用於放gRPC客戶端demo的相關類。

首先我們需要寫程式碼來實現將電話增加到使用者的邏輯，我們在com.ylifegroup.protobuf.service包下新建一個類叫PhoneServiceImp，它只需要繼承protoc-gen-grpc外掛幫我們自己生成的一個grpc實現類PhoneServiceGrpc.PhoneServiceImplBase，並實現相關方法即可，所有程式碼如下所示：

package com.ylifegroup.protobuf.service;

import com.ylifegroup.protobuf.PhoneServiceGrpc;
import com.ylifegroup.protobuf.Phonebook.AddPhoneToUserRequest;
import com.ylifegroup.protobuf.Phonebook.AddPhoneToUserResponse;

import io.grpc.stub.StreamObserver;

public class PhoneServiceImp extends PhoneServiceGrpc.PhoneServiceImplBase{

    @Override
    public void addPhoneToUser(AddPhoneToUserRequest request, StreamObserver<AddPhoneToUserResponse> responseObserver) {
        // TODO Auto-generated method stub
        AddPhoneToUserResponse response = null;
        if(request.getPhoneNumber().length() == 11 ){
            System.out.printf("uid = %s , phone type is %s, nubmer is %s\n", request.getUid(), request.getPhoneType(), request.getPhoneNumber());
            response = AddPhoneToUserResponse.newBuilder().setResult(true).build();
        }else{
            System.out.printf("The phone nubmer %s is wrong!\n",request.getPhoneNumber());
            response = AddPhoneToUserResponse.newBuilder().setResult(false).build();
        }
        responseObserver.onNext(response);
        responseObserver.onCompleted();
    }

}

程式碼很簡單，我們只是檢查手機號是不是11位，如果是把客戶端的請求引數打印出來，給客戶端返回true，如果不是11位，提示手機號錯誤，給客戶端返回false。

程式碼很簡單，這裡就不詳細解釋了。

接下來，我們需要將我們實現的服務釋出成grpc服務，這裡有很多實現方法，我們就使用grpc官方提供的用netty實現伺服器程式碼，還記得在gradle的配置檔案裡我們增加了io.grpc:grpc-netty:1.0.3依賴嗎？就是用在這的。

在com.ylifegroup.protobuf.server包下新建GRpcServer類，程式碼如下所示（大部分程式碼參考grpc官方的helloworld）：

package com.ylifegroup.protobuf.server;

import io.grpc.Server;
import io.grpc.ServerBuilder;
import java.io.IOException;
import java.util.logging.Logger;
import com.ylifegroup.protobuf.service.PhoneServiceImp;

public class GRpcServer {
    private static final Logger logger = Logger.getLogger(GRpcServer.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 PhoneServiceImp())
                .build()
                .start();
        logger.info("Server started, listening on " + port);
        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                System.err.println("*** shutting down gRPC server since JVM is shutting down");
                GRpcServer.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 GRpcServer server = new GRpcServer();
        server.start();
        server.blockUntilShutdown();
    }
}

詳細的我就不解釋了，一看程式碼就能明白，只需要把我們的電話本服務PhoneServiceImp增加到grpc伺服器，然後就能對外提供電話本的服務了。

gRPC服務的客戶端實現

客戶端的實現也很簡單，在com.ylifegroup.protobuf.client包下新建GRpcClient類，程式碼如下：

package com.ylifegroup.protobuf.client;

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;

import com.ylifegroup.protobuf.PhoneServiceGrpc;
import com.ylifegroup.protobuf.Phonebook.AddPhoneToUserRequest;
import com.ylifegroup.protobuf.Phonebook.AddPhoneToUserResponse;
import com.ylifegroup.protobuf.Phonebook.PhoneType;

public class GRpcClient {

    private static final Logger logger = Logger.getLogger(GRpcClient.class.getName());

    private final ManagedChannel channel;

    private final PhoneServiceGrpc.PhoneServiceBlockingStub blockingStub;

    /** Construct client connecting to gRPC server at {@code host:port}. */
    public GRpcClient(String host, int port) {
        ManagedChannelBuilder<?> channelBuilder = ManagedChannelBuilder.forAddress(host, port).usePlaintext(true);
        channel = channelBuilder.build();
        blockingStub = PhoneServiceGrpc.newBlockingStub(channel);
    }

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

    /** add phone to user. */
    public void addPhoneToUser(int uid, PhoneType phoneType, String phoneNubmer) {
        logger.info("Will try to add phone to user " + uid);
        AddPhoneToUserRequest request = AddPhoneToUserRequest.newBuilder().setUid(uid).setPhoneType(phoneType)
                .setPhoneNumber(phoneNubmer).build();
        AddPhoneToUserResponse response;
        try {
            response = blockingStub.addPhoneToUser(request);
        } catch (StatusRuntimeException e) {
            logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
            return;
        }
        logger.info("Result: " + response.getResult());
    }

    public static void main(String[] args) throws Exception {
        GRpcClient client = new GRpcClient("localhost", 50051);
        try {
            client.addPhoneToUser(1, PhoneType.WORK, "13888888888");
        } finally {
            client.shutdown();
        }
    }
}

程式碼也很簡單，自己看吧，總結下來呼叫gRPC服務包括以下幾步：

• 指定伺服器端的ip和埠，構建一個ManagedChannel。
• 構造gRPC請求相關引數。
• 建立blockingStub（回到開始去看看那張圖，就更好理解stub了）來呼叫相關的遠端方法。
• 接收伺服器端返回結果。

這其中大部分的程式碼protoc-gen-grpc都已經幫您生成，使用起來很方便。

讓它跑起來

我們在專案根目錄執行如下命令：

./gradlew jar

會在build/libs/目錄下生成一個可直接執行的jar包：gRPCDemo.jar。

我們執行如下命令即可啟動我們的gRPC服務：

java -jar build/libs/gRPCDemo.jar

如下圖所示：

我們在eclipse中執行GRpcClient類，您將看到：

看到了嗎？伺服器端返回”true”。

把程式碼中的8去掉一個，再次執行，如下圖所示：

伺服器端返回了false，說明我們的服務還是靠譜的，哈哈。

這只是我們的第一個grpc版本，以方便你更好的理解grpc，後面我將結合spring boot講解微服務架構，那就更牛B了。