gRPC

gRPC基于Golang和Java的简单实现

2018-08-13  本文已影响7人  贾顺

原文连接： 一文了解RPC以及gRPC基于Golang和Java的简单实现

一：什么是RPC

二：常用RPC框架选型

如何选择：

如果公司项目使用Java并不牵扯到跨语言，且规模并没有大到难以治理，我推荐Dubbo。如果项目规模大，服务调用错综复杂，我推荐SpringCloud。

如果牵扯到跨语言，我推荐gRPC，这也是目前我司的选择。即使Thrift性能是gRPC的2倍，但没办法，它有个好爹，现在我们的开发环境考虑最多的还是生态。

三：gRPC的原理

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

对于序列化gRPC采用了自家公司开源的Protobuf。什么是Protobuf？先看一句网络上 大部分的解释：

Google Protocol Buffer(简称 Protobuf)是一种轻便高效的结构化数据存储格式，平台无关、语言无关、可扩展，可用于通讯协议和数据存储等领域。

上句有几个关键点：它是一种数据存储格式，跨语言，跨平台，用于通讯协议和数据存储。

这么看和我们熟悉的JSON类似，但其实着重点有些本质的区别。JSON主要是用于数据的传输，因为它轻量级，可读性好，解析简单。Protobuf主要是用于跨语言的IDL，它除了和JSON、XML一样能定义结构体之外，还可以使用自描述格式定于出接口的特性，并可以使用针对不同语言的protocol编译器产生不同语言的stub类。所以天然的适用于跨语言的RPC框架中。

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

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

四：代码的简单实现

概念永远都是枯燥的，只有实战才能真正理解问题。下面我们使用代码基于以上的步骤来实现一个简单gRPC。为了体现gRPC跨语言的特性，这次我们使用两种语言：Go实现server端，Java作为client端来实现。

1：安装Protocol Buffers，定义.proto文件

登录Google的 github下载对应Protocol Buffers版本。

安装完成后当我们执行protoc命令如果返回如下信息说明安装成功。

protoc

下面我们定义一个simple.proto文件，这也是后续我们实现gRPC的基础

syntax = "proto3"; //定义了我们使用的Protocol Buffers版本。

 //表明我们定义了一个命名为Simple的服务(接口)，内部有一个远程rpc方法，名字为SayHello。
 //我们只要在server端实现这个接口，在实现类中书写我们的业务代码。在client端调用这个接口。
 service Simple{
    rpc SayHello(HelloRequest) returns (HelloReplay){}
 }

 //请求的结构体
 message HelloRequest{
     string name = 1;
 }
 //返回的结构体
 message HelloReplay{
     string message = 1;
 }

通过上面的注释可以看出此文件是一个简单的RPC远程方法描述。

2：使用Golang实现sever端

根据官方文档使用如下命令安装针对Go的gRPC:

$ go get -u google.golang.org/grpc

但是由于我们有伟大的长城，一般这条命令都不会下载成功。但Google的文件一般都会在github存有一份镜像。我们可以使用如下命令：

$ go get -u github.com/grpc/grpc-go

随后将下载的文件夹重命名为go，并放入一个新建的google.golang.org的文件夹中。🤷‍♀️

当我们安装完gRPC并定义好了远程接口调用的具体信息后，我们要使用protocol编译器生成我们的stub程序。

我们安装的Protocol Buffers是用来编译我们的.proto文件的，但是编译后的文件是不能被Java、C、Go等这些语言使用。Google针对不同的语言有不同的编译器。本次我们使用Golang语言，所以要安装针对Golang的编译器，根据官方提供的命令执行：

$ go get -u github.com/golang/protobuf/protoc-gen-go

但有可能我们会下载不成功，因为这个会依赖很多Golang的类库，这些类库和上面安装gRPC一样，鉴于墙的原因，还要执行一系列繁琐的改文件夹的步骤。但这个不是我们的重点，就不细说了。

安装成功之后我们就可以建立Go的project了。

本次我们建立一个grpc-server的项目，然后将前面写的simple.proto放入项目proto的package中。

随后在项目的目录下使用命令行执行如下命令：

protoc -I grpc-server/ proto/simple.proto --go_out=plugins=grpc:simple

这样就将simple.proto编译成了Go语言对应的stub程序了。

随后我们就可以写我们server端的代码了：main.go。

package main

import (
    "context"
    "grpc-server/proto"
    "fmt"
    "net"
    "log"
    "google.golang.org/grpc"
    "google.golang.org/grpc/reflection"
)

const(
    port = ":50051"
)

type server struct{}

func (s *server) SayHello(ctx context.Context,req *simple.HelloRequest) (*simple.HelloReplay, error){

    fmt.Println(req.Name)

    return &simple.HelloReplay{Message:"hello =======> " + req.Name},nil
}

func main(){
    lis,err := net.Listen("tcp",port)

    if err != nil {
        log.Fatal("fail to listen")
    }

    s := grpc.NewServer()

    simple.RegisterSimpleServer(s,&server{})

    reflection.Register(s)

    if err:= s.Serve(lis);err != nil{
        log.Fatal("fail to server")
    }
}

以上的代码都是模板代码，main函数是socket使用Go的标准实现。作为开发者我们只关注远程服务提供的具体接口实现即可。

最终我们的项目目录是这样的：

go-server

就这样一个使用Go语言实现的最简单server端就完成了。

3：使用Java实现client端

相对来说Java实现就简单一些，首先我们可以使用熟悉的Maven插件进行stub代码的生成。

新建一个grpc-client的父项目，两个子项目：client和lib。lib用于stub程序的代码生成。

lib项目编辑pom.xml，添加gRPC针对Java的插件编译器：

<?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>org.js</groupId>
    <artifactId>grpc-client</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>

    <modules>
        <module>client</module>
    </modules>

    <name>grpc-client</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <grpc.version>1.13.1</grpc.version>
        <springboot.version>2.0.4.RELEASE</springboot.version>
    </properties>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter</artifactId>
                <version>${springboot.version}</version>
            </dependency>
            <dependency>
                <groupId>io.grpc</groupId>
                <artifactId>grpc-netty</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>

            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
                <version>${springboot.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>


    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

将定义好的simple.proto文件拷贝项目proto的package下。随后右键：Run Maven——compile。

maven

生成完成后将target下图中的两个文件拷贝到client项目目录中。

target

之后就是编写我们的业务代码进行gRPC的远程调用了。本次我们写一个简单的web程序模拟远程的调用。

定义一个class：SimpleClient：

package org.js.client.grpc;

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

import java.util.concurrent.TimeUnit;

/**
 * @author JiaShun
 * @date 2018/8/11 12:11
 */
public class SimpleClient {
    private final ManagedChannel channel;
    private final SimpleGrpc.SimpleBlockingStub blockingStub;
    public SimpleClient(String host, int port){
        this(ManagedChannelBuilder.forAddress(host, port).usePlaintext());
    }

    private SimpleClient(ManagedChannelBuilder<?> channelBuilder){
        channel = channelBuilder.build();
        blockingStub = SimpleGrpc.newBlockingStub(channel);
    }

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

    public String sayHello(String name){
        SimpleOuterClass.HelloRequest req = SimpleOuterClass.HelloRequest.newBuilder().setName(name).build();
        SimpleOuterClass.HelloReplay replay = blockingStub.sayHello(req);
        return replay.getMessage();
    }
}

基本都是模板代码。下面再编写一个简单的web请求：

controller代码：

package org.js.client.controller;

import org.js.client.service.IHelloService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author JiaShun
 * @date 2018/8/10 22:20
 */
@RestController
public class HelloController {
    @Autowired
    private IHelloService helloService;

    @GetMapping("/{name}")
    public String sayHello(@PathVariable String name){
        return helloService.sayHello(name);
    }
}

service实现类：

package org.js.client.service;

import org.js.client.grpc.SimpleClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

/**
 * @author JiaShun
 * @date 2018/8/10 22:22
 */
@Service
public class HelloServiceImpl implements IHelloService{
    private Logger logger = LoggerFactory.getLogger(HelloServiceImpl.class);
    @Value("${gRPC.host}")
    private String host;
    @Value("${gRPC.port}")
    private int port;

    @Override
    public String sayHello(String name) {
        SimpleClient client = new SimpleClient(host,port);
        String replay = client.sayHello(name);
        try {
            client.shutdown();
        } catch (InterruptedException e) {
            logger.error("channel关闭异常：err={}",e.getMessage());
        }
        return replay;
    }

}

就这么简单。

随后我们测试一下：

分别启动Go server端，Java client端。

gRPC-start

访问：http://localhost:8080/jiashun

gRPC-test

可以发现server端打印出了client端的请求，client端也收到了server端的返回。

完整代码：

server：https://github.com/jia-shun/grpc-server

client：https://github.com/jia-shun/grpc-client

上一篇 下一篇

猜你喜欢

热点阅读