Kotlin में gRPC: लाइब्रेरी और उपयोग के उदाहरण

Kotlin में gRPC: लाइब्रेरी और उपयोग के उदाहरण

gRPC एक हाई-परफॉर्मेंस RPC (Remote Procedure Call) फ्रेमवर्क है जिसे Google ने विकसित किया है। यह डेटा सीरियलाइजेशन के लिए Protocol Buffers (protobuf) और ट्रांसपोर्ट के लिए HTTP/2 का उपयोग करता है। Kotlin इकोसिस्टम में, gRPC कोरूटीन और स्ट्रिक्ट टाइपिंग को सपोर्ट करने वाली लाइब्रेरीज़ की बदौलत बेहद आसानी से इंटीग्रेट हो जाता है। इस आर्टिकल में हम Kotlin में gRPC के लिए ज़रूरी मुख्य टूल्स पर चर्चा करेंगे और सर्वर तथा क्लाइंट के वर्किंग उदाहरण देंगे।

मुख्य लाइब्रेरीज़

Kotlin में gRPC के साथ काम करने के लिए निम्नलिखित स्टैक की आवश्यकता होगी:

• grpc-kotlin — Google की आधिकारिक लाइब्रेरी, जो Kotlin-विशिष्ट API प्रदान करती है, जिसमें कोरूटीन (suspend फंक्शन, Flow) का सपोर्ट शामिल है।
• protobuf-java और protobuf-gradle-plugin — .proto फाइलों से क्लासेस जनरेट करने के लिए।
• grpc-netty या grpc-okhttp — ट्रांसपोर्ट लेयर (सर्वर के लिए Netty, Android/क्लाइंट के लिए OkHttp)।
• javax.annotation-api — जनरेटेड कोड के सही कंपाइलेशन के लिए अक्सर आवश्यक।

डिपेंडेंसी मैनेजमेंट के लिए Gradle (Kotlin DSL) का उपयोग करें। डिपेंडेंसी ब्लॉक का उदाहरण:

dependencies {
    implementation("io.grpc:grpc-netty-shaded:1.58.0")
    implementation("io.grpc:grpc-protobuf:1.58.0")
    implementation("io.grpc:grpc-stub:1.58.0")
    implementation("io.grpc:grpc-kotlin-stub:1.4.0")
    implementation("com.google.protobuf:protobuf-java:3.24.3")
    implementation("javax.annotation:javax.annotation-api:1.3.2")
}

साथ ही, कोड जनरेशन के लिए protobuf प्लगइन को कॉन्फ़िगर करना न भूलें:

plugins {
    id("com.google.protobuf") version "0.9.4"
}

protobuf {
    protoc {
        artifact = "com.google.protobuf:protoc:3.24.3"
    }
    plugins {
        create("grpc") {
            artifact = "io.grpc:protoc-gen-grpc-java:1.58.0"
        }
        create("grpckt") {
            artifact = "io.grpc:protoc-gen-grpc-kotlin:1.4.0:jdk8@jar"
        }
    }
    generateProtoTasks {
        all().forEach {
            it.plugins {
                create("grpc")
                create("grpckt")
            }
        }
    }
}

.proto फ़ाइल के माध्यम से सर्विस डिफ़ाइन करना

एक फ़ाइल बनाएँ src/main/proto/hello.proto:

syntax = "proto3";

package com.example.grpc;

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

Gradle बिल्ड चलाने के बाद, ये क्लासेस जनरेट होंगी: HelloRequest, HelloReply, GreeterGrpc और GreeterGrpcKt (कोरूटीन के साथ Kotlin वर्शन)।

Kotlin में gRPC सर्वर इम्प्लीमेंटेशन

सर्वर जनरेटेड क्लास GreeterGrpcKt.GreeterCoroutineImplBase का उपयोग करेगा:

import com.example.grpc.GreeterGrpcKt
import com.example.grpc.HelloReply
import com.example.grpc.HelloRequest
import io.grpc.ServerBuilder
import kotlinx.coroutines.runBlocking

class GreeterService : GreeterGrpcKt.GreeterCoroutineImplBase() {
    override suspend fun sayHello(request: HelloRequest): HelloReply {
        val message = "नमस्ते, ${request.name}!"
        println("अनुरोध प्राप्त हुआ: ${request.name}")
        return HelloReply.newBuilder().setMessage(message).build()
    }
}

fun main() {
    val port = 50051
    val server = ServerBuilder.forPort(port)
        .addService(GreeterService())
        .build()

    server.start()
    println("सर्वर पोर्ट $port पर शुरू हो गया है")
    server.awaitTermination()
}

Kotlin में gRPC क्लाइंट इम्प्लीमेंटेशन

क्लाइंट कोरूटीन सपोर्ट के साथ चैनल और stub का उपयोग करता है:

import com.example.grpc.GreeterGrpcKt
import com.example.grpc.HelloRequest
import io.grpc.ManagedChannelBuilder
import kotlinx.coroutines.runBlocking