103. Studi Kasus: Client Android (Java/Kotlin) berkomunikasi dengan gRPC Server di Go

title: “103. Studi Kasus: Client Android (Java/Kotlin) berkomunikasi dengan gRPC Server di Go” author: “Andika Pratama” date: 2024-06-10 tags: [android, kotlin, go, grpc, distributed-system, client-server]

gRPC telah menjadi tulang punggung banyak sistem distributed modern—baik untuk microservices, mobile backend, maupun cloud-native applications. Studi kasus kali ini menyoroti bagaimana client Android (dengan Java/Kotlin) dapat berkomunikasi secara efisien dengan gRPC server yang ditulis dalam Go (Golang). Artikel ini akan menuntun Anda mulai dari motivasi, rancangan hingga kode nyata yang dapat menunjang pengembangan aplikasi lintas platform dengan performa tinggi.

Kenapa gRPC?

Alasan utama memakai gRPC antara lain:

• Efisiensi: Serialisasi Protobuf jauh lebih efisien daripada JSON.
• Contract-first: Antar komponen (Android dan server Go) berinteraksi dengan schema interface yang sudah jelas.
• Built-in codegen: Stub client/server bisa dihasilkan otomatis dari file .proto.
• Streaming & Bidi: Mendukung komunikasi streaming, bukan hanya unary request-response.
• Ecosystem: Resmi didukung Google dan open source.

Diagram Alur Sistem

Mari lihat gambaran umum komunikasi antara Android Client (Kotlin) dan Go gRPC Server:

sequenceDiagram
    participant AndroidClient as Android Client (Kotlin/Java)
    participant gRPCServer as gRPC Server (Go)

    AndroidClient->>gRPCServer: Protobuf Request
    gRPCServer-->>AndroidClient: Protobuf Response

1. Mendesain Service dengan Protobuf

Sebelum implementasi kode, kita mulai dengan mendefinisikan interface service di file helloworld.proto:

syntax = "proto3";

package helloworld;

// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}

2. Implementasi gRPC Server di Go

Kita mulai dulu dari sisi server:

a. Persiapan environment

Install gRPC dan Protobuf dependencies:

go get google.golang.org/grpc
go get google.golang.org/protobuf/cmd/protoc-gen-go
go get google.golang.org/grpc/cmd/protoc-gen-go-grpc

Generate file interface:

protoc --go_out=. --go-grpc_out=. helloworld.proto

b. Kode Go (server/main.go)

package main

import (
  "context"
  "log"
  "net"
  "google.golang.org/grpc"
  pb "path/to/your/helloworld"
)

type server struct {
  pb.UnimplementedGreeterServer
}

// Implement the SayHello method
func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
  log.Printf("Received: %v", in.GetName())
  return &pb.HelloReply{Message: "Hello " + in.GetName()}, nil
}

func main() {
  lis, err := net.Listen("tcp", ":50051")
  if err != nil {
    log.Fatalf("failed to listen: %v", err)
  }
  s := grpc.NewServer()
  pb.RegisterGreeterServer(s, &server{})
  log.Printf("server listening at %v", lis.Addr())
  if err := s.Serve(lis); err != nil {
    log.Fatalf("failed to serve: %v", err)
  }
}

3. Menyiapkan Android Client (Kotlin)

gRPC Java mendukung Android secara native. Workflow-nya kurang lebih sebagai berikut:

a. Persiapan environment

Tambahkan dependencies di build.gradle:

dependencies {
    implementation "io.grpc:grpc-okhttp:1.57.2"
    implementation "io.grpc:grpc-protobuf-lite:1.57.2"
    implementation "io.grpc:grpc-stub:1.57.2"
}

Generate stub dari file .proto:

protoc \
  --java_out=app/src/main/java \
  --grpc-java_out=app/src/main/java \
  helloworld.proto

Atur agar folder Java hasil kodegen masuk dalam sourceSets.

b. Contoh kode Kotlin di Activity

import io.grpc.ManagedChannelBuilder
import helloworld.GreeterGrpc
import helloworld.HelloRequest

fun sayHelloToServer(user: String): String {
    val channel = ManagedChannelBuilder.forAddress("YOUR.SERVER.IP.ADDRESS", 50051)
        .usePlaintext() // untuk testing development, jangan production!
        .build()

    val stub = GreeterGrpc.newBlockingStub(channel)
    val request = HelloRequest.newBuilder().setName(user).build()

    return try {
        val response = stub.sayHello(request)
        response.message
    } catch (e: Exception) {
        "RPC failed: ${e.localizedMessage}"
    } finally {
        channel.shutdown()
    }
}

Misal pada MainActivity:

lifecycleScope.launch(Dispatchers.IO) {
    val greeting = sayHelloToServer("Andika")
    withContext(Dispatchers.Main) {
        Toast.makeText(this@MainActivity, greeting, Toast.LENGTH_SHORT).show()
    }
}

4. Simulasi Request-Response

Mari kita cek apa yang terjadi ketika pengguna Android menyapa server Go dengan nama “Andika”:

Output di Android akan berupa Toast:
Hello Andika

5. Permasalahan Yang Sering Muncul & Tips

Masalah Umum

6. Analisa Performa

Kecepatan Serialisasi

Hemat bandwidth dan mempercepat startup waktu respons.

7. Kesimpulan

Dengan studi kasus praktis ini, Anda dapat membangun komunikasi gRPC dari Android ke server Go secara efisien. gRPC membuka jalan untuk integrasi lintas platform secara seamless, menawarkan kecepatan, skalabilitas, dan kemudahan maintainability yang sangat penting di era aplikasi mobile modern dan arsitektur microservices.

Jika tertarik melangkah lebih lanjut, pelajari advanced topic seperti gRPC streaming, interceptors, auth, dan load balancing. Selamat bereksperimen dan semoga sukses membangun aplikasi mobile-backend yang tangguh menggunakan Kotlin dan Go!

Referensi:

• gRPC Java (Android Guide)
• gRPC Go Quick Start
• Protobuf Language Guide