Skip to content
Santekno.com | Level Up Your Engineering Skills
ID
📖 0%
18 Jun 2025 · 5 mnt baca ·Artikel 10 / 110
Go

10 Struktur Kode Otomatis yang Dihasilkan oleh `protoc`

IH
Ihsan Arif
Penulis di Santekno · Backend Engineer

Bayangkan Anda sedang mengembangkan layanan microservices yang membutuhkan pertukaran data antar berbagai layanan. Protokol data yang digunakan harus efisien, mudah diperluas, dan mendukung beberapa bahasa pemrograman. Di sinilah Protocol Buffers (protobuf) menjadi solusi yang sangat relevan.

Dengan mengandalkan tool protoc, file definisi .proto dapat dikompilasi menjadi kode dalam berbagai bahasa secara otomatis. Tetapi, apa sebenarnya yang dihasilkan oleh protoc? Bagaimana struktur kode otomatis tersebut? Bagaimana pengembang bisa memanfaatkannya secara optimal?

Artikel ini akan mengupas secara mendalam struktur kode otomatis yang dihasilkan oleh protoc, lengkap dengan contoh implementasi, simulasi pemakaian, dan diagram alur proses.

Mengenal protoc dan Proses Generasi Kode

protoc merupakan Protocol Buffer Compiler resmi dari Google. Ia “memakan” file .proto dan mengeluarkan kode sumber (class, enum, service stub) yang siap digunakan pada project aplikasi Anda.

Prosesnya dapat digambarkan dengan diagram berikut:

MERMAID
flowchart LR
    A[Definisi .proto] --> B[protoc]
    B --> C{Bahasa Target}
    C -->|Go| D[File .pb.go]
    C -->|Java| E[File .java]
    C -->|Python| F[File _pb2.py]
    C -->|C++| G[File .pb.h & .pb.cc]

Simulasi: File .proto Sederhana

Mari kita ambil contoh file .proto berikut (user.proto):

proto
1syntax = "proto3";
2
3package user;
4
5message User {
6  int32 id = 1;
7  string name = 2;
8  string email = 3;
9}

Eksekusi protoc

Kita jalankan perintah:

bash
1protoc --go_out=. user.proto

Hasilnya adalah file user.pb.go yang siap Anda gunakan di aplikasi Go.

Struktur Kode Otomatis: Anatomi File *_pb.go (Go)

Mari kita bedah isi dan strukturnya.

1. Header, Licensing & Imports

go
 1// Code generated by protoc-gen-go. DO NOT EDIT.
 2// versions:
 3// 	protoc-gen-go v1.25.0
 4// 	protoc        v3.14.0
 5package user
 6
 7import (
 8	proto "github.com/golang/protobuf/proto"
 9	reflect "reflect"
10	sync "sync"
11)

Biasanya bagian awal selalu berupa komentar “DO NOT EDIT” dan informasi versi. Kemudian import untuk library protobuf runtime.

2. Deklarasi Struct

Setiap message pada file .proto akan menjadi struct di Go:

go
1type User struct {
2	Id    int32  `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
3	Name  string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
4	Email string `protobuf:"bytes,3,opt,name=email,proto3" json:"email,omitempty"`
5}

Field ini disertai tag meta untuk protobuf serialization dan JSON serialization.

Tabel Mapping Field

.proto SyntaxStruct Go Otomatis
int32 id = 1;Id int32
string name = 2;Name string
string email = 3;Email string

3. Method Serialisasi dan Utilities

Struct hasil generasi protoc selalu memiliki method untuk (de)serialisasi:

go
1func (x *User) Reset()         { ... }
2func (x *User) String() string { ... }
3func (*User) ProtoMessage()    {}
4func (x *User) ProtoReflect() protoreflect.Message {
5    ...
6}

Metode ini adalah interface antara Protobuf runtime dengan objek data aplikasi Anda.

4. Descriptor dan Registration

Bagian metadata file .proto akan terlihat seperti ini:

go
1var File_user_proto protoreflect.FileDescriptor
2var file_user_proto_rawDesc = [...]byte{...}
3func init() {
4    ... // Registrasi file descriptor
5}

Bagian ini penting untuk refleksi dan evolusi schema.

Menjelajah Hasil Generasi protoc dalam Bahasa Lain

Setiap bahasa memiliki konvensi masing-masing atas hasil kode generator. Berikut ringkasan dalam bentuk tabel:

BahasaOutput utamaTipe MessageSerialisasiNama file
GoStruct & Type MethodstructMarshal/X.pb.go
JavaKelas & builderclass + BuilderparseFrom().java
PythonKelasclass (CamelCase)SerializeToString()_pb2.py
C++ClassclassSerializeToString().pb.h/.pb.cc

Studi Kasus: Menggunakan Struct Go Hasil Generasi

Kode Simulasi

go
 1package main
 2
 3import (
 4	"fmt"
 5	"log"
 6	"user" // dari hasil compilasi user.pb.go
 7
 8	"google.golang.org/protobuf/proto"
 9)
10
11func main() {
12	// Membuat instance User
13	u := &user.User{
14		Id:    123,
15		Name:  "Bagus Prakoso",
16		Email: "bagus@company.com",
17	}
18
19	// Serialisasi ke byte array
20	raw, err := proto.Marshal(u)
21	if err != nil {
22		log.Fatal("Serialize error:", err)
23	}
24
25	fmt.Println("Protobuf bytes:", raw)
26
27	// Deserialisasi ke objek User
28	baru := &user.User{}
29	if err := proto.Unmarshal(raw, baru); err != nil {
30		log.Fatal("Deserialize error:", err)
31	}
32
33	fmt.Printf("Hasil decode: id=%v, name=%v, email=%v\n",
34		baru.Id, baru.Name, baru.Email)
35}

Keluaran program:

bash
1Protobuf bytes: [8 123 18 14 66 97 103 117 115 32 80 114 97 107 111 115 111 26 19 98 97 103 117 115 64 99 111 109 112 97 110 121 46 99 111 109]
2Hasil decode: id=123, name=Bagus Prakoso, email=bagus@company.com

Diagram Alur Serialisasi-Deserialisasi Protobuf Struct

Proses di atas dapat digambarkan sebagai berikut:

MERMAID
flowchart LR
    A[Struct User di Go] --> B["Marshal (Serialisasi)"]
    B --> C["[]byte"]
    C --> D["Unmarshal (Deserialisasi)"]
    D --> E[Struct User]

Ada Apa Lagi di File Kode Otomatis?

Jika file .proto Anda makin rumit—misal ada enum, oneof, nested message, dan service definition—kode generator akan otomatis menambah:

  • Kode enum (enum/constant)
  • Nested message & oneof sebagai struct dan interface
  • Client/Server interface untuk RPC (jika ada service)
  • Fungsi validasi dan refleksi tambahan

Contoh deklarasi enum:

proto
1enum Status {
2  UNKNOWN = 0;
3  ACTIVE = 1;
4  INACTIVE = 2;
5}
6message Account {
7  Status status = 1;
8}

Potongan hasil Go (disederhanakan):

go
1type Status int32
2
3const (
4  Status_UNKNOWN Status = 0
5  Status_ACTIVE Status = 1
6  Status_INACTIVE Status = 2
7)

Kesimpulan

Struktur kode otomatis hasil protoc adalah tulang punggung bagi integrasi tipe data kuat pada aplikasi lintas bahasa dan platform. Dengan pemahaman detail terhadap apa yang dihasilkan—baik dalam bentuk struct/message, method utility, maupun registration—engineer dapat:

  • Mempercepat pengembangan aplikasi distributed tanpa menulis boilerplate serialization
  • Memastikan kompatibilitas antar services dan versi aplikasi
  • Melacak dependency dan evolusi schema data dengan mudah

Jika Anda ingin memperluas kapabilitas—misal, menambah cross-language gRPC service stub—cukup perluas file .proto, dan jalankan kembali protoc.

Tips untuk para engineer: Selalu review hasil file otomatis, pahami kontrak antar module, dan pastikan Anda mengutilisasi setiap metode yang tersedia dari hasil generasi.

Referensi tambahan:

Selamat mencoba dan eksplorasi struktur kode otomatis dari protoc lebih dalam lagi! 🚀

Artikel Terkait

💬 Komentar