Go untuk pengembangan mobile: sisi server, API, dan utilitas

Apa itu Go?

Go — bahasa terkompilasi dengan pengetikan statis dan manajemen memori otomatis melalui pengumpul sampah. Tujuan utama Go: kompilasi cepat, kesederhanaan kode, dan dukungan konkurensi bawaan. Go dikompilasi menjadi biner native tanpa mesin virtual — satu file eksekusi berisi semuanya, termasuk dependensi.

Pustaka standar Go mencakup server HTTP, marshaling JSON, penguraian flag baris perintah, enkripsi, dan bekerja dengan basis data. Untuk server HTTP tidak perlu framework eksternal — net/http sudah bawaan. Go Modules (sejak versi 1.16) — sistem manajemen dependensi standar. Versi saat ini — Go 1.23 (2025) dengan paket iter yang ditingkatkan untuk iterator.

Go dirancang untuk memecahkan masalah penskalaan yang dihadapi Google: kompilasi C++ yang lambat, kompleksitas Java, konkurensi Python yang tidak efisien. Hasilnya — bahasa yang digunakan untuk menulis Docker, Kubernetes, Prometheus, Terraform, dan Hugo.

Sintaks Go

Go minimalis: 25 kata kunci (sebagai perbandingan C++ memiliki 84). Tidak ada kelas, pewarisan, generik (hingga versi 1.18), kelebihan muatan operator, dan pengecualian. Kesalahan ditangani secara eksplisit melalui pengembalian err. Struktur dan antarmuka menggantikan OOP.

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
)

type User struct {
	ID    int    `json:"id"`
	Name  string `json:"name"`
	Email string `json:"email"`
}

func userHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	user := User{ID: 1, Name: "Alice", Email: "alice@example.com"}
	json.NewEncoder(w).Encode(user)
}

func main() {
	http.HandleFunc("/api/user", userHandler)
	fmt.Println("Server di :8080")
	http.ListenAndServe(":8080", nil)
}

Struktur User dengan tag JSON menentukan serialisasi. http.HandleFunc mendaftarkan penangan. json.NewEncoder(w).Encode(user) menyerialisasi struktur langsung ke JSON dalam respons. Server HTTP bawaan memproses permintaan secara otomatis di goroutine terpisah.

Goroutines dan saluran: model konkurensi Go

Goroutines — utas eksekusi ringan yang dikelola oleh runtime Go. Tidak seperti utas OS (tumpukan 1–8 MB), goroutine dimulai dengan tumpukan 4 KB yang tumbuh secara dinamis. Anda dapat menjalankan 100.000 goroutine di satu server. Menjalankan goroutine — go functionName().

Saluran (channels) — antrian bertipe untuk mengirim data antar goroutine. Saluran dibuat melalui make(chan Type). Operator <- mengirim data, <-chan menerima. Saluran dapat berupa buffer (dengan kapasitas) dan non-buffer (sinkron).

package main

import (
	"fmt"
	"net/http"
	"time"
)

func fetchURL(url string, ch chan<- string) {
	start := time.Now()
	resp, err := http.Get(url)
	if err != nil {
		ch <- fmt.Sprintf("Kesalahan: %s", err)
		return
	}
	defer resp.Body.Close()
	elapsed := time.Since(start)
	ch <- fmt.Sprintf("%s — %dms", url, elapsed.Milliseconds())
}

func main() {
	urls := []string{"https://google.com", "https://github.com", "https://stackoverflow.com"}
	ch := make(chan string, len(urls))

	for _, url := range urls {
		go fetchURL(url, ch)
	}

	for range urls {
		fmt.Println(<-ch)
	}
}

Tiga permintaan dijalankan secara paralel melalui go fetchURL. Saluran ch mengumpulkan hasil. defer resp.Body.Close() menjamin penutupan respons saat kembali dari fungsi. select {} tidak digunakan karena semua goroutine mengirim ke saluran — utas utama membaca tepat len(urls) kali.

Go untuk sisi server aplikasi mobile

Go — salah satu bahasa terbaik untuk backend aplikasi mobile. HTTP/2 dan HTTP/3 bawaan, serialisasi protobuf/gRPC cepat, dan konsumsi memori rendah menjadikan Go ideal untuk API yang melayani ribuan klien mobile.

Framework populer: Gin (hingga 10x lebih cepat dari Express.js), Echo (minimalis, JWT middleware), Fiber (bergaya Express), Chi (kompatibel dengan net/http). Gin adalah yang paling populer dengan 70k+ bintang di GitHub. Untuk gRPC digunakan google.golang.org/grpc.

package main

import (
	"database/sql"
	"log"
	"net/http"
	"time"

	"github.com/gin-gonic/gin"
	_ "github.com/mattn/go-sqlite3"
)

func main() {
	db, err := sql.Open("sqlite3", "mobile_app.db")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	r := gin.Default()
	r.GET("/api/v1/posts", func(c *gin.Context) {
		type Post struct {
			ID        int       `json:"id"`
			Title     string    `json:"title"`
			CreatedAt time.Time `json:"created_at"`
		}
		rows, _ := db.Query("SELECT id, title, created_at FROM posts ORDER BY created_at DESC LIMIT 20")
		defer rows.Close()

		var posts []Post
		for rows.Next() {
			var p Post
			rows.Scan(&p.ID, &p.Title, &p.CreatedAt)
			posts = append(posts, p)
		}
		c.JSON(http.StatusOK, posts)
	})
	r.Run(":8080")
}

Gin.GET mendaftarkan rute dengan penangan. sql.Open membuka basis data SQLite, db.Query menjalankan kueri. c.JSON menyerialisasi potongan posts menjadi array JSON. Fungsi anonim di dalam GET menangkap db dari konteks eksternal. Gin menangani panic, mencatat log permintaan, dan mendukung middleware.

Mikroservis dan gateway API dalam Go

Go — bahasa utama untuk arsitektur mikroservis. Konsumsi memori rendah per mikroservis (15–30 MB) memungkinkan menjalankan puluhan servis di satu server. Mulai cepat (milidetik) dan ukuran biner kecil (10–20 MB) menyederhanakan penyebaran dalam kontainer.

Gateway API dalam Go menggabungkan permintaan dari aplikasi mobile ke servis internal. Gateway Golang menangani otentikasi (JWT), pembatasan laju, perutean, dan penembolokan. Implementasi populer: Kong (berbasis OpenResty dan plugin Go), Tyk (dalam Go), gateway sendiri di Gin.

gRPC dan protobuf

gRPC — framework pemanggilan prosedur jarak jauh dari Google, menggunakan Protocol Buffers untuk serialisasi dan HTTP/2 untuk transport. Go memiliki dukungan gRPC terbaik di antara semua bahasa. Untuk backend mobile, gRPC memberikan throughput 5–10 kali lebih tinggi daripada REST/JSON.

package main

import (
	"context"
	"log"
	"net"

	"google.golang.org/grpc"
	pb "example.com/proto"
)

type server struct {
	pb.UnimplementedUserServiceServer
}

func (s *server) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.UserResponse, error) {
	return &pb.UserResponse{
		Id:    req.Id,
		Name:  "Alice",
		Email: "alice@example.com",
	}, nil
}

func main() {
	lis, _ := net.Listen("tcp", ":50051")
	s := grpc.NewServer()
	pb.RegisterUserServiceServer(s, &server{})
	log.Fatal(s.Serve(lis))
}

pb.UnimplementedUserServiceServer — stub yang dihasilkan oleh protoc dari file .proto. Struktur server menimpa metode GetUser. grpc.NewServer() membuat server dengan interceptor untuk pencatatan, otentikasi, dan metrik.

Go untuk utilitas CLI dan alat pengembang

Go — bahasa terbaik untuk utilitas CLI yang digunakan dalam pengembangan mobile. Satu biner statis (~10 MB) tanpa dependensi berfungsi di semua platform: macOS, Linux, Windows. Kompilasi memakan waktu detik. Utilitas Go tidak memerlukan instalasi interpreter atau runtime.

Contoh alat Go dalam ekosistem mobile: Migrate (migrasi DB), Kubectl (Kubernetes untuk backend mobile), Terraform (infrastruktur), Prometheus (pemantauan). Pengembang menulis utilitas Go untuk menghasilkan model dari file proto, validasi konfigurasi, dan penyebaran mikroservis.

package main

import (
	"flag"
	"fmt"
	"os"
)

func main() {
	project := flag.String("project", "", "Project directory")
	version := flag.String("version", "1.0.0", "App version")
	verbose := flag.Bool("verbose", false, "Verbose output")
	flag.Parse()

	if *project == "" {
		fmt.Println("Penggunaan: deploy --project=path [--version=x.x.x]")
		os.Exit(1)
	}

	if *verbose {
		fmt.Printf("Menyebarkan proyek %s versi %s
", *project, *version)
	}
	// di sini logika penyebaran
	fmt.Println("Penyebaran selesai")
}

flag.String mendefinisikan flag string baris perintah dengan nama, nilai default, dan deskripsi. flag.Parse() mengurai argumen os.Args. Pointer *project di-dereferensi untuk mendapatkan nilai. Biner dibangun dengan perintah go build -o deploy deploy.go.

Gomobile: Go dalam pustaka native untuk iOS dan Android

Gomobile — alat Google untuk mengompilasi kode Go menjadi pustaka native mobile. go bind -target=android menghasilkan .aar untuk Android, go bind -target=ios menghasilkan .xcframework untuk iOS. Ini memungkinkan penulisan logika bisnis bersama dalam Go dan memanggilnya dari Kotlin dan Swift.

Skenario utama Gomobile: kriptografi (skema enkripsi sendiri), bekerja dengan jaringan (protokol sendiri melalui WebSocket), pemrosesan data (kompresi, pengkodean, penguraian). UI tidak ditulis dalam Go — tugasnya adalah menggantikan C++ untuk modul native lintas platform.

package mobile

import "crypto/aes"

// EncryptData mengenkripsi data AES-256-GCM (diekspor ke .aar)
func EncryptData(key []byte, plaintext []byte) ([]byte, error) {
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	ciphertext := make([]byte, len(plaintext))
	block.Encrypt(ciphertext, plaintext)
	return ciphertext, nil
}

func DecryptData(key []byte, ciphertext []byte) ([]byte, error) {
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	plaintext := make([]byte, len(ciphertext))
	block.Decrypt(plaintext, ciphertext)
	return plaintext, nil
}

Fungsi yang diekspor (dengan huruf kapital) dibungkus oleh Gomobile ke dalam antarmuka Java/Swift. Dari Kotlin, panggilan terlihat seperti Mobile.encryptData(key, plaintext). Gomobile secara otomatis mengonversi tipe: []byte → byte[] (Java) / Data (Swift).

Go vs Java dan Kotlin untuk backend: perbandingan

Go bersaing dengan Java dan Kotlin dalam pengembangan server. Perbedaan utama: Go dikompilasi menjadi biner native, tidak memerlukan JVM, mengonsumsi 2–3 kali lebih sedikit memori, dan mulai dalam milidetik. Java unggul dalam kematangan ekosistem dan jumlah pustaka.

Go dipilih untuk mikroservis, gateway API, dan alat. Java/Kotlin — untuk aplikasi enterprise dengan logika bisnis yang kaya. Dalam pengembangan mobile, kombinasi optimal: Go untuk backend, Kotlin/Swift untuk klien.