虽然我可以用io.grpc:protoc gen grpc kotlin生成存根，但我可以'；我不能实施它

问题：我无法实现从protobuf自动生成的对象

如何复制：从micronaut初始值设定项生成一个项目：gRPC应用程序类型，Java 11，Kotlin。在build.gradle上添加io.grpc:protoc gen grpc kotlin，构建它，添加控制器并尝试实现GrpcdemoServiceGrpcKt

格雷德尔先生

    plugins {
    id "org.jetbrains.kotlin.jvm" version "1.4.10"
    id "org.jetbrains.kotlin.kapt" version "1.4.10"
    id "org.jetbrains.kotlin.plugin.allopen" version "1.4.10"
    id "com.github.johnrengelman.shadow" version "6.1.0"
    id "io.micronaut.application" version '1.0.5'
    id "com.google.protobuf" version "0.8.13"
}

version "0.1"
group "com.mybank"

repositories {
    mavenCentral()
    jcenter()
}

micronaut {
    testRuntime "junit5"
    processing {
        incremental true
        annotations "com.mybank.*"
    }
}

dependencies {
    implementation("io.micronaut:micronaut-validation")
    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:${kotlinVersion}")
    implementation("org.jetbrains.kotlin:kotlin-reflect:${kotlinVersion}")
    implementation("io.micronaut.kotlin:micronaut-kotlin-runtime")
    implementation("io.micronaut:micronaut-runtime")
    implementation("io.micronaut.grpc:micronaut-grpc-runtime")
    implementation("javax.annotation:javax.annotation-api")
    runtimeOnly("ch.qos.logback:logback-classic")
    runtimeOnly("com.fasterxml.jackson.module:jackson-module-kotlin")
    testImplementation("io.micronaut:micronaut-http-client")

    implementation("io.grpc:grpc-kotlin-stub:${grpcKotlinVersion}")
}

mainClassName = "com.mybank.ApplicationKt"
java {
    sourceCompatibility = JavaVersion.toVersion('11')
}

compileKotlin {
    kotlinOptions {
        jvmTarget = '11'
    }
}
compileTestKotlin {
    kotlinOptions {
        jvmTarget = '11'
    }
}



sourceSets {
    main {
        java {
            srcDirs 'build/generated/source/proto/main/grpc'
            srcDirs 'build/generated/source/proto/main/java'
        }
    }
}

protobuf {
    protoc { artifact = "com.google.protobuf:protoc:3.13.0" }
    plugins {
        grpc { artifact = "io.grpc:protoc-gen-grpc-java:1.32.1" }
        grpckt { artifact = "io.grpc:protoc-gen-grpc-kotlin:${grpcKotlinVersion}" }
    }
    generateProtoTasks {
        all()*.plugins {
            grpc {}
            grpckt {}
        }
    }
}

格拉德尔酒店

micronautVersion=2.1.3
kotlinVersion=1.4.10
grpcKotlinVersion=0.1.2

所有其他的都与micronaut.launch完全相同

可能的解决方案：我下载了一个示例，成功地启动了它，并从BloomRPC调用了它。这是来自官方的例子。看着它，我看到一个更复杂的渐变

从Hello World构建gradle

plugins {
    id "org.jetbrains.kotlin.jvm" version "1.3.72"
    id "org.jetbrains.kotlin.kapt" version "1.3.72"
    id "org.jetbrains.kotlin.plugin.allopen" version "1.3.72"
    id "application"
    id 'com.google.protobuf' version '0.8.13'
}

version "0.2"
group "helloworld"

repositories {
    mavenLocal()
    jcenter()
}

configurations {
    // for dependencies that are needed for development only
    developmentOnly
}

dependencies {
    kapt(enforcedPlatform("io.micronaut:micronaut-bom:$micronautVersion"))
    kapt("io.micronaut:micronaut-inject-java")
    kapt("io.micronaut:micronaut-validation")

    implementation(enforcedPlatform("io.micronaut:micronaut-bom:$micronautVersion"))
    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:${kotlinVersion}")
    implementation("org.jetbrains.kotlin:kotlin-reflect:${kotlinVersion}")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlinxCoroutinesVersion")
    implementation("io.micronaut:micronaut-runtime")
//    implementation("io.micronaut.grpc:micronaut-grpc-runtime")
    implementation("io.micronaut.grpc:micronaut-grpc-server-runtime:$micronautGrpcVersion")
    implementation("io.micronaut.grpc:micronaut-grpc-client-runtime:$micronautGrpcVersion")
    implementation("io.grpc:grpc-kotlin-stub:${grpcKotlinVersion}")

    runtimeOnly("ch.qos.logback:logback-classic:1.2.3")
    runtimeOnly("com.fasterxml.jackson.module:jackson-module-kotlin:2.9.8")

    kaptTest("io.micronaut:micronaut-inject-java")

    testImplementation enforcedPlatform("io.micronaut:micronaut-bom:$micronautVersion")
    testImplementation("org.junit.jupiter:junit-jupiter-api:5.3.0")
    testImplementation("io.micronaut.test:micronaut-test-junit5")
    testImplementation("org.mockito:mockito-junit-jupiter:2.22.0")

    testRuntime("org.junit.jupiter:junit-jupiter-engine:5.3.0")
    testRuntime("org.jetbrains.spek:spek-junit-platform-engine:1.1.5")
}

test.classpath += configurations.developmentOnly

mainClassName = "helloworld.Application"

test {
    useJUnitPlatform()
}

allOpen {
    annotation("io.micronaut.aop.Around")
}

compileKotlin {
    kotlinOptions {
        jvmTarget = '1.8' 
        //Will retain parameter names for Java reflection
        javaParameters = true 
    }
}
//compileKotlin.dependsOn(generateProto)

compileTestKotlin {
    kotlinOptions {
        jvmTarget = '1.8' 
        javaParameters = true 
    }
}

tasks.withType(JavaExec) {
    classpath += configurations.developmentOnly
    jvmArgs('-XX:TieredStopAtLevel=1', '-Dcom.sun.management.jmxremote')
}

sourceSets {
    main {
        java {
            srcDirs 'build/generated/source/proto/main/grpc'
            srcDirs 'build/generated/source/proto/main/grpckt'
            srcDirs 'build/generated/source/proto/main/java'
        }
    }
}

protobuf {
    protoc { artifact = "com.google.protobuf:protoc:${protocVersion}" }
    plugins {
        grpc { artifact = "io.grpc:protoc-gen-grpc-java:${grpcVersion}" }
        grpckt { artifact = "io.grpc:protoc-gen-grpc-kotlin:${grpcKotlinVersion}" }
    }
    generateProtoTasks {
        all()*.plugins {
            grpc {}
            grpckt {}
        }
    }
}

问题：自从自动生成存根以来，为了实现它，我缺少了什么？除了io.grpc:protoc gen grpc kotlin之外，我还需要更多的渐变依赖吗？我想不是。我的方向对吗？如果没有，我应该怎么做才能从Micronaut.launch下载的演示项目中实现send rpc方法

注：当我尝试io的最新版本时。grpc:protoc gen grpc kotlin gradle抱怨，所以我只使用了0.1.2，这与官方示例中的相同。这对我来说不是问题，只要它与我的问题无关

---

免责声明：最初在

中被问到，我对此也有一些问题

我认为您真正想要做的是实现生成并驻留在GrpcKt文件中的ImplBase，而不是整个对象本身

我在这里开始了一个示例，您可以遵循：

---

我对这个也有一些问题

我认为您真正想要做的是实现生成并驻留在GrpcKt文件中的ImplBase，而不是整个对象本身

我在这里开始了一个示例，您可以遵循：

导入org.jetbrains.kotlin.gradle.tasks.KotlinCompile
导入com.google.protobuf.gradle*
group=“store.service”
version=“0.0.1-快照”
构建脚本{
依赖关系{
类路径（kotlin（“gradle插件”，version=“1.4.20”））
类路径（“com.google.protobuf:protobuf-gradle插件：0.8.14”）
类路径（“io.micronaut.gradle:micronaut-gradle插件：1.2.0”）
}
}
插件{
主意
kotlin（“jvm”）版本“1.4.20”
kotlin（“plugin.serialization”）版本“1.4.20”
id（“com.google.protobuf”）版本“0.8.14”
id（“com.github.johnrengelman.shadow”）版本“6.1.0”
id（“io.micronaut.application”）版本“1.2.0”
}
微型机器人{
运行时（“netty”）
testRuntime（“junit5”）
加工{
增量（真）
注释（“store.service.*”）
}
}
应用{
mainClass.set（“store.service.App.java”）
}
爪哇{
sourceCompatibility=JavaVersion.toVersion（“1.8”）
targetCompatibility=JavaVersion.toVersion（“1.8”）
}
存储库{
mavenCentral（）
jcenter（）
}
依赖关系{
/*
8使用GraalVM生成Micronaut应用程序的本机映像
注释处理器（“io.micronaut:micronaut-graal”）
*/
实施（“io.micronaut:micronaut验证”）
实现（“io.micronaut:micronaut运行时”）
实现（“io.micronaut.grpc:micronaut-grpc服务器运行时：2.2.0”）
实现（“io.micronaut.mongodb:micronaut-mongo-reactive:3.1.0”）
实施（“org.jetbrains.kotlin:kotlin reflect”）
实现（“org.jetbrains.kotlin:kotlin stdlib”）
实施（“org.jetbrains.kotlinx:kotlinx coroutines reactor:1.4.2”）
实现（“org.jetbrains.kotlinx:kotlinx协同程序核心：1.4.2”）
实现（“org.jetbrains.kotlinx:kotlinx序列化协议：1.0.1”）
实施（“io.grpc:grpc协议lite:1.33.1”）
实施（“io.grpc:grpc协议：1.33.1”）
实施（“io.grpc:grpc kotlin存根lite:0.2.1”）
实施（“io.grpc:grpc净额：1.33.1”）
实现（“com.google.protobuf:protobufjava:3.14.0”）
实现（“com.google.guava:guava:30.0-jre”）
实现（“javax.annotation:javax.annotation api:1.3.2”）
实现（“org.slf4j:slf4j simple:2.0.0-alpha1”）
测试实现（“io.kotest:kotest-runner-junit5-jvm:4.2.5”）
}
任务{
withType{
科特洛普斯酒店{
freeCompilerArgs=listOf（“-Xjsr305=strict”）
jvmTarget=“11”
}
}
withType{
useJUnitPlatform（）
}
}
protobuf{
原始人{
artifact=“com.google.protobuf:protoc:3.11.4”
}
插件{
id（“grpc”）{
artifact=“io.grpc:protoc gen grpc java:1.25.0”
}
id（“grpckt”）{
artifact=“io.grpc:protoc gen grpc kotlin:0.2.0:jdk7@jar"
}
}
生成原型任务{
资源集（“主要”）。forEach{
it.plugins{
id（“grpc”）
id（“grpckt”）
}
}
}
}

在您的GrpcdemoServiceGrpcK中，您将找到您的ImplBase。在此基础上实施具体的grpc服务。

导入org.jetbrains.kotlin.gradle.tasks.KotlinCompile
导入com.google.protobuf.gradle*
group=“store.service”
version=“0.0.1-快照”
构建脚本{
依赖关系{
类路径（kotlin（“gradle插件”，version=“1.4.20”））
类路径（“com.google.protobuf:protobuf-gradle插件：0.8.14”）
类路径（“io.micronaut.gradle:micronaut-gradle插件：1.2.0”）
}
}
插件{
主意
kotlin（“jvm”）版本“1.4.20”
kotlin（“plugin.serialization”）版本“1.4.20”
id（“com.google.protobuf”）版本“0.8.14”
id（“com.github.johnrengelman.shadow”）版本“6.1.0”
id（“io.micronaut.application”）版本“1.2.0”
}
微型机器人{
运行时（“netty”）
testRuntime（“junit5”）
加工{
增量（真）
注释（“store.service.*”）
}
}
应用{
mainClass.set（“store.service.App.java”）
}
爪哇{
sourceCompatibility=JavaVersion.toVersion（“1.8”）
targetCompatibility=JavaVersion.toV

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
import com.google.protobuf.gradle.*

group = "store.service"
version = "0.0.1-SNAPSHOT"

buildscript {

    dependencies {
        classpath(kotlin("gradle-plugin", version = "1.4.20"))
        classpath("com.google.protobuf:protobuf-gradle-plugin:0.8.14")
        classpath("io.micronaut.gradle:micronaut-gradle-plugin:1.2.0")
    }
}

plugins {
    idea
    kotlin("jvm") version "1.4.20"
    kotlin("plugin.serialization") version "1.4.20"
    id("com.google.protobuf") version "0.8.14"
    id("com.github.johnrengelman.shadow") version "6.1.0"
    id("io.micronaut.application") version "1.2.0"
}

micronaut {
    runtime("netty")
    testRuntime("junit5")
    processing {
        incremental(true)
        annotations("store.service.*")
    }
}

application {
    mainClass.set("store.service.App.java")
}

java {
    sourceCompatibility = JavaVersion.toVersion("1.8")
    targetCompatibility = JavaVersion.toVersion("1.8")
}


repositories {
    mavenCentral()
    jcenter()
}

dependencies {

/*
8 Generating a Micronaut Application's Native Image with GraalVM
    annotationProcessor("io.micronaut:micronaut-graal")
*/

    implementation("io.micronaut:micronaut-validation")
    implementation("io.micronaut:micronaut-runtime")
    implementation("io.micronaut.grpc:micronaut-grpc-server-runtime:2.2.0")
    implementation("io.micronaut.mongodb:micronaut-mongo-reactive:3.1.0")

    implementation("org.jetbrains.kotlin:kotlin-reflect")
    implementation("org.jetbrains.kotlin:kotlin-stdlib")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-reactor:1.4.2")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.2")
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-protobuf:1.0.1")

    implementation("io.grpc:grpc-protobuf-lite:1.33.1")
    implementation("io.grpc:grpc-protobuf:1.33.1")
    implementation("io.grpc:grpc-kotlin-stub-lite:0.2.1")
    implementation("io.grpc:grpc-netty:1.33.1")
    implementation("com.google.protobuf:protobuf-java:3.14.0")
    implementation("com.google.guava:guava:30.0-jre")

    implementation("javax.annotation:javax.annotation-api:1.3.2")
    implementation("org.slf4j:slf4j-simple:2.0.0-alpha1")

    testImplementation("io.kotest:kotest-runner-junit5-jvm:4.2.5")
}

tasks {

    withType<KotlinCompile> {
        kotlinOptions {
            freeCompilerArgs = listOf("-Xjsr305=strict")
            jvmTarget = "11"
        }
    }

    withType<Test> {
        useJUnitPlatform()
    }
}

protobuf {
    protoc {
        artifact = "com.google.protobuf:protoc:3.11.4"
    }
    plugins {
        id("grpc") {
            artifact = "io.grpc:protoc-gen-grpc-java:1.25.0"
        }
        id("grpckt") {
            artifact = "io.grpc:protoc-gen-grpc-kotlin:0.2.0:jdk7@jar"
        }
    }

    generateProtoTasks {
        ofSourceSet("main").forEach {
            it.plugins {
                id("grpc")
                id("grpckt")
            }
        }
    }
}