java版gRPC实战之一：用proto生成代码

淩亂°似流年 2022-11-11 14:59 281阅读 0赞

### 欢迎访问我的GitHub ###

> 这里分类和汇总了欣宸的全部原创(含配套源码)：[https://github.com/zq2599/blog\_demos][https_github.com_zq2599_blog_demos]

### 关于《java版gRPC实战》系列 ###

*  《java版gRPC实战》是欣宸原创的面向java程序员的gRPC开发笔记，与读者们一起通过实战来学习掌握gRPC的各个知识点；

### 《java版gRPC实战》全系列链接 ###

1.  [用proto生成代码][proto]
2.  [服务发布和调用][Link 1]
3.  [服务端流][Link 2]
4.  [客户端流][Link 3]
5.  [双向流][Link 4]
6.  [客户端动态获取服务端地址][Link 5]
7.  [基于eureka的注册发现][eureka]

### 关于gRPC ###

1.  gRPC 是一个高性能、开源和通用的 RPC 框架，面向移动和 HTTP/2 设计。目前提供 C、Java 和 Go 语言版本，分别是：grpc, grpc-java, grpc-go. 其中 C 版本支持 C, C++, Node.js, Python, Ruby, Objective-C, PHP 和 C\# 支持.
2.  gRPC 基于 HTTP/2 标准设计，带来诸如双向流、流控、头部压缩、单 TCP 连接上的多复用请求等特。这些特性使得其在移动设备上表现更好，更省电和节省空间占用。
3.  各个进程之间可以通过gRPC相互调用，如下图：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70]

### 核心技术 ###

*  为了用java发布gRPC服务，我使用的是开源库net.devh:grpc-server-spring-boot-starter
 *  在调用其他gRPC服务时用的是net.devh:grpc-client-spring-boot-starter
 *  感谢该开源库的作者Michael大神，您的智慧的简化了java程序员的gRPC开发工作，项目地址：https://github.com/yidongnan/grpc-spring-boot-starter

### 本篇概览 ###

作为系列文章的开篇，本篇要做的事情如下：

1.  明确依赖库和开发环境
2.  新建父工程grpc-tutorials，今后《java版gRPC实战》系列的所有源码都在这个工程中
3.  实战用proto文件自动生成java代码

### 明确依赖库和开发环境 ###

整个系列文章涉及的依赖库和开发环境的情况如下：

1.  JDK：1.8.0\_281
2.  gradle：6.7.1
3.  springboot：2.3.8.RELEASE
4.  grpc：1.35.0
5.  protobuf：3.14.0
6.  grpc-server-spring-boot-starter：2.11.0.RELEASE
7.  grpc-client-spring-boot-starter：2.11.0.RELEASE
8.  操作系统：win10专业版
9.  IDEA：2021.1 (Ultimate Edition)

### 源码下载 ###

*  本篇实战中的完整源码可在GitHub下载到，地址和链接信息如下表所示(https://github.com/zq2599/blog\_demos)：

<table> 
 <thead> 
  <tr> 
   <th align="left">名称</th> 
   <th align="left">链接</th> 
   <th align="left">备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">项目主页</td> 
   <td align="left">https://github.com/zq2599/blog_demos</td> 
   <td align="left">该项目在GitHub上的主页</td> 
  </tr> 
  <tr> 
   <td align="left">git仓库地址(https)</td> 
   <td align="left">https://github.com/zq2599/blog_demos.git</td> 
   <td align="left">该项目源码的仓库地址，https协议</td> 
  </tr> 
  <tr> 
   <td align="left">git仓库地址(ssh)</td> 
   <td align="left">git@github.com:zq2599/blog_demos.git</td> 
   <td align="left">该项目源码的仓库地址，ssh协议</td> 
  </tr> 
 </tbody> 
</table>

*  这个git项目中有多个文件夹，《java版gRPC实战》系列的源码在grpc-tutorials文件夹下，如下图红框所示：  
    ![在这里插入图片描述][2021041720563940.png]

### 创建《java版gRPC实战》系列的父工程 ###

*  新建名为grpc-tutorials的gradle工程，前面提到的库及其版本都在此工程中处理好，build.gradle内容如下：

import java.time.OffsetDateTime
    import java.time.format.DateTimeFormatter
    
    buildscript { 
        repositories { 
            maven { 
                url 'https://plugins.gradle.org/m2/'
            }
            // 如果有私服就在此配置，如果没有请注释掉
            maven { 
                url 'http://192.168.50.43:8081/repository/aliyun-proxy/'
            }
            // 阿里云
            maven { 
                url 'http://maven.aliyun.com/nexus/content/groups/public/'
            }
    
            mavenCentral()
        }
        ext { 
            // 项目版本
            projectVersion = '1.0-SNAPSHOT'
    
            // 依赖库的版本
            grpcSpringBootStarterVersion = '2.11.0.RELEASE'
    
            // grpc版本 https://github.com/grpc/grpc-java/releases
            grpcVersion = '1.35.0'
            // protobuf版本 https://github.com/protocolbuffers/protobuf/releases
            protobufVersion = '3.14.0'
            // protobuf的gradle插件版本
            protobufGradlePluginVersion = '0.8.12'
    
            // sprignboot版本 https://github.com/spring-projects/spring-boot/releases
            springBootVersion = '2.3.8.RELEASE'
            // springcloud版本 https://github.com/spring-cloud/spring-cloud-release/releases
            springCloudVersion = 'Hoxton.SR9'
            // nacos版本 https://github.com/alibaba/spring-cloud-alibaba/releases
            springCloudAlibabaNacosVersion = '2.2.3.RELEASE'
            // security版本 https://github.com/spring-projects/spring-security-oauth/releases
            springSecurityOAuthVersion = '2.5.0.RELEASE'
        }
    }
    
    plugins { 
        id 'java'
        id 'java-library'
        id 'org.springframework.boot' version "${springBootVersion}" apply false
        id 'io.spring.dependency-management' version '1.0.11.RELEASE'
        id 'net.nemerosa.versioning' version '2.14.0'
        id 'com.google.protobuf' version '0.8.14'
        id 'io.franzbecker.gradle-lombok' version '4.0.0' apply false
        id 'com.github.ben-manes.versions' version '0.36.0' // gradle dependencyUpdates
    }
    
    // If you attempt to build without the `--scan` parameter in `gradle 6.0+` it will cause a build error that it can't find
    // a buildScan property to change. This avoids that problem.
    if (hasProperty('buildScan')) { 
        buildScan { 
            termsOfServiceUrl = 'https://gradle.com/terms-of-service'
            termsOfServiceAgree = 'yes'
        }
    }
    
    wrapper { 
        gradleVersion = '6.7.1'
    }
    
    def buildTimeAndDate = OffsetDateTime.now()
    
    ext { 
        // 构建时取得当前日期和时间
        buildDate = DateTimeFormatter.ISO_LOCAL_DATE.format(buildTimeAndDate)
        buildTime = DateTimeFormatter.ofPattern('HH:mm:ss.SSSZ').format(buildTimeAndDate)
        buildRevision = versioning.info.commit
    }
    
    allprojects { 
        apply plugin: 'java'
        apply plugin: 'idea'
        apply plugin: 'eclipse'
        apply plugin: 'io.spring.dependency-management'
        apply plugin: 'io.franzbecker.gradle-lombok'
    
        compileJava { 
            sourceCompatibility = JavaVersion.VERSION_1_8
            targetCompatibility = JavaVersion.VERSION_1_8
            options.encoding = 'UTF-8'
        }
    
        compileJava.options*.compilerArgs = [
                '-Xlint:all', '-Xlint:-processing'
        ]
    
        // Copy LICENSE
        tasks.withType(Jar) { 
            from(project.rootDir) { 
                include 'LICENSE'
                into 'META-INF'
            }
        }
    
        // 写入到MANIFEST.MF中的内容
        jar { 
            manifest { 
                attributes(
                        'Created-By': "${System.properties['java.version']} (${System.properties['java.vendor']} ${System.properties['java.vm.version']})".toString(),
                        'Built-By': 'travis',
                        'Build-Date': buildDate,
                        'Build-Time': buildTime,
                        'Built-OS': "${System.properties['os.name']}",
                        'Build-Revision': buildRevision,
                        'Specification-Title': project.name,
                        'Specification-Version': projectVersion,
                        'Specification-Vendor': 'Will Zhao',
                        'Implementation-Title': project.name,
                        'Implementation-Version': projectVersion,
                        'Implementation-Vendor': 'Will Zhao'
                )
            }
        }
    
        repositories { 
            mavenCentral()
    
            // 如果有私服就在此配置，如果没有请注释掉
            maven { 
                url 'http://192.168.50.43:8081/repository/aliyun-proxy/'
            }
    
            // 阿里云
            maven { 
                url 'http://maven.aliyun.com/nexus/content/groups/public/'
            }
    
            jcenter()
        }
    
        buildscript { 
            repositories { 
                maven {  url 'https://plugins.gradle.org/m2/' }
            }
        }
    }
    
    allprojects {  project ->
        buildscript { 
            dependencyManagement { 
                imports { 
                    mavenBom "org.springframework.boot:spring-boot-starter-parent:${springBootVersion}"
                    mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
                    mavenBom "com.google.protobuf:protobuf-bom:${protobufVersion}"
                    mavenBom "io.grpc:grpc-bom:${grpcVersion}"
                    mavenBom "org.junit:junit-bom:5.7.0"
                }
    
                dependencies { 
                    dependency 'org.projectlombok:lombok:1.16.16'
                    dependency 'org.apache.commons:commons-lang3:3.11'
                    dependency 'commons-collections:commons-collections:3.2.2'
                    dependency "net.devh:grpc-server-spring-boot-starter:${grpcSpringBootStarterVersion}"
                    dependency "net.devh:grpc-client-spring-boot-starter:${grpcSpringBootStarterVersion}"
                }
            }
    
            ext { 
                micrometerVersion = dependencyManagement.importedProperties['micrometer.version']
                springFrameworkVersion = dependencyManagement.importedProperties['spring-framework.version']
                springSecurityVersion = dependencyManagement.importedProperties['spring-security.version']
                springCloudCommonsVersion = dependencyManagement.importedProperties['spring-cloud-commons.version']
            }
        }
    }
    
    group = 'com.bolingcavalry'
    version = projectVersion

*  整个系列用到的父工程已经完成，接下来可以开始编码了；

### 实战用proto文件自动生成java代码 ###

*  gRPC服务能够用不同的语言编写，其中的关键是定义服务的proto文件可以被生成各种语言的代码，java也不例外，接下来一起体验；
 *  在父工程grpc-tutorials下新建模块，名为grpc-lib，其build.gradle内容如下，可见主要是配置了protobuf插件，以及生成的java代码如何才能被IDE工具加入到source path中：

// 根据proto生成java代码的gradle插件
    plugins { 
        id 'com.google.protobuf'
    }
    
    dependencies { 
        implementation 'io.grpc:grpc-netty-shaded'
        implementation 'io.grpc:grpc-protobuf'
        implementation 'io.grpc:grpc-stub'
        if (JavaVersion.current().isJava9Compatible()) { 
            // Workaround for @javax.annotation.Generated
            // see: https://github.com/grpc/grpc-java/issues/3633
            implementation 'jakarta.annotation:jakarta.annotation-api'
        }
    }
    
    
    protobuf { 
        protoc { 
            artifact = "com.google.protobuf:protoc:${protobufVersion}"
        }
        // 自动生成的代码放在这里
        generatedFilesBaseDir = "$projectDir/src/generated"
        clean { 
            delete generatedFilesBaseDir
        }
        // 生成java代码的插件
        plugins { 
            grpc { 
                artifact = 'io.grpc:protoc-gen-grpc-java'
            }
        }
        generateProtoTasks { 
            all()*.plugins { 
                grpc { }
            }
        }
    }
    
    // 对于eclipse，通过以下脚本可以将生成的代码加入source路径中，编译时会被用到
    eclipse { 
        classpath { 
            file.beforeMerged {  cp ->
                def generatedGrpcFolder = new org.gradle.plugins.ide.eclipse.model.SourceFolder('src/generated/main/grpc', null);
                generatedGrpcFolder.entryAttributes['ignore_optional_problems'] = 'true';
                cp.entries.add( generatedGrpcFolder );
                def generatedJavaFolder = new org.gradle.plugins.ide.eclipse.model.SourceFolder('src/generated/main/java', null);
                generatedJavaFolder.entryAttributes['ignore_optional_problems'] = 'true';
                cp.entries.add( generatedJavaFolder );
            }
        }
    }
    
    // 对于idea，通过以下脚本可以将生成的代码加入source路径中，编译时会被用到
    idea { 
        module { 
            sourceDirs += file('src/generated/main/java')
            sourceDirs += file('src/generated/main/grpc')
            generatedSourceDirs += file('src/generated/main/java')
            generatedSourceDirs += file('src/generated/main/grpc')
        }
    }

*  在grpc-lib模块的src/main/proto目录下新增名为helloworld.proto的文件，这里面定义了一个gRPC服务，里面含有一个接口，并且还有这个接口的入参和返回结果的定义：

syntax = "proto3";
    
    option java_multiple_files = true;
    // 生成java代码的package
    option java_package = "com.bolingcavalry.grpctutorials.lib";
    option java_outer_classname = "HelloWorldProto";
    
    // gRPC服务
    service Simple { 
        // 接口定义
        rpc SayHello (HelloRequest) returns (HelloReply) { 
        }
    }
    
    // 入参的数据结构
    message HelloRequest { 
        string name = 1;
    }
    
    // 返回结果的数据结构
    message HelloReply { 
        string message = 1;
    }

*  proto文件已经做好，接下来要根据这个文件来生成java代码，在grpc-tutorials目录下执行命令gradle grpc-lib:generateProto，即可根据helloworld.proto文件生成java代码，执行成功后会生出下图红框中的内容，这些就是java代码：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 1]
 *  本篇只聊如何生成上述代码，至于这些代码的用途就留到下一篇再说吧，这里只简单提一下，SimpleGrpc里面有抽象类SimpleImplBase，制作gRPC服务的时候需要继承该类，另外，如果您要远程调用gRPC的sayHello接口，就会用到SimpleGrpc类中的SimpleStub类，其余的HelloReply、HelloRequest这些则是入参和返回的数据结构定义；
 *  至此，java版gRPC实战的准备工作就完成了，根据proto文件生成java代码的方法也掌握了，接下来的章节咱们一起尝试服务的发布和调用；

### 你不孤单，欣宸原创一路相伴 ###

1.  [Java系列][Java]
2.  [Spring系列][Spring]
3.  [Docker系列][Docker]
4.  [kubernetes系列][kubernetes]
5.  [数据库+中间件系列][Link 6]
6.  [DevOps系列][DevOps]

### 欢迎关注公众号：程序员欣宸 ###

> 微信搜索「程序员欣宸」，我是欣宸，期待与您一同畅游Java世界…

[https_github.com_zq2599_blog_demos]: https://github.com/zq2599/blog_demos
[proto]: https://xinchen.blog.csdn.net/article/details/115049443
[Link 1]: https://xinchen.blog.csdn.net/article/details/115803738
[Link 2]: https://xinchen.blog.csdn.net/article/details/115983001
[Link 3]: https://xinchen.blog.csdn.net/article/details/116097756
[Link 4]: https://xinchen.blog.csdn.net/article/details/116354293
[Link 5]: https://xinchen.blog.csdn.net/article/details/116479078
[eureka]: https://xinchen.blog.csdn.net/article/details/116635441
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70]: /images/20221022/f031c660d3ec4341a9b155db1db35bd9.png
[2021041720563940.png]: /images/20221022/16fb60812ac243ccaabf03f9731d9054.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210417201323406.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5,size_16,color_FFFFFF,t_70
[Java]: https://xinchen.blog.csdn.net/article/details/105068742
[Spring]: https://xinchen.blog.csdn.net/article/details/105086498
[Docker]: https://xinchen.blog.csdn.net/article/details/105086732
[kubernetes]: https://xinchen.blog.csdn.net/article/details/105086794
[Link 6]: https://xinchen.blog.csdn.net/article/details/105086850
[DevOps]: https://xinchen.blog.csdn.net/article/details/105086920