Go para sa mobile development: bahagi ng server, API at mga kagamitan

Ano ang Go?

Go — isang statically typed compiled language na may automatic memory management sa pamamagitan ng garbage collector. Pangunahing layunin ng Go: mabilis na compilation, simplisidad ng code at built-in na suporta para sa concurrency. Nagko-compile ang Go sa native binary na walang virtual machine — isang executable file ay naglalaman ng lahat, kabilang ang dependencies.

Sinasaklaw ng standard library ng Go ang HTTP server, JSON marshaling, pag-parse ng command line flags, encryption at pagtatrabaho sa databases. Para sa HTTP server ay hindi kailangan ng external framework — built-in ang net/http. Go Modules (mula sa version 1.16) — standard system para sa dependency management. Kasalukuyang version — Go 1.23 (2025) na may pinahusay na iter package para sa mga iterator.

Ang Go ay dinisenyo para malutas ang mga problema sa scaling na hinarap ng Google: mabagal na compilation ng C++, komplikasyon ng Java, hindi epektibong concurrency ng Python. Resulta — wikang ginamit sa pagsulat ng Docker, Kubernetes, Prometheus, Terraform at Hugo.

Sintaks ng Go

Minimalist ang Go: 25 keyword (para sa paghahambing ang C++ ay may 84). Walang klase, inheritance, generics (hanggang version 1.18), operator overloading at exceptions. Ang mga error ay hinahawakan nang tahasan sa pamamagitan ng pagbabalik ng err. Ang mga structure at interface ay pumapalit sa 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 sa :8080")
	http.ListenAndServe(":8080", nil)
}

Ang structure User na may JSON tags ay tumutukoy sa serialization. Ang http.HandleFunc ay nagrerehistro ng handler. Ang json.NewEncoder(w).Encode(user) ay nagsi-serialize ng structure diretso sa JSON sa response. Ang built-in na HTTP server ay nagpoproseso ng mga request awtomatiko sa magkakahiwalay na goroutine.

Goroutines at channels: modelo ng concurrency ng Go

Goroutines — magaan na execution thread na pinamamahalaan ng Go runtime. Hindi tulad ng OS threads (1–8 MB stack), ang goroutine ay nagsisimula sa 4 KB stack na dynamic na lumalaki. Maaaring magpatakbo ng 100,000 goroutine sa isang server. Pagpapatakbo ng goroutine — go functionName().

Channels — naka-type na pila para sa paglipat ng data sa pagitan ng goroutines. Ang channel ay ginagawa sa pamamagitan ng make(chan Type). Ang operator <- ay nagpapadala ng data, <-chan ay tumatanggap. Ang channels ay maaaring buffered (may kapasidad) at unbuffered (synchronous).

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("Error: %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)
	}
}

Tatlong request ay isinasagawa nang parallel sa pamamagitan ng go fetchURL. Ang channel ch ay nangongolekta ng mga resulta. Ang defer resp.Body.Close() ay ginagarantiyahan ang pagsasara ng response sa pagbalik mula sa function. Ang select {} ay hindi ginagamit dahil lahat ng goroutine ay nagpapadala sa channel — ang main thread ay nagbabasa nang eksaktong len(urls) beses.

Go para sa bahagi ng server ng mobile applications

Go — isa sa pinakamahusay na wika para sa backend ng mobile applications. Ang built-in na HTTP/2 at HTTP/3, mabilis na protobuf/gRPC serialization at mababang memory consumption ay ginagawang perpekto ang Go para sa API na naglilingkod sa libu-libong mobile clients.

Sikat na frameworks: Gin (hanggang 10x mas mabilis kaysa Express.js), Echo (minimalist, JWT middleware), Fiber (sa estilo ng Express), Chi (compatible sa net/http). Ang Gin ang pinakasikat na may 70k+ stars sa GitHub. Para sa gRPC ay ginagamit ang 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")
}

Ang Gin.GET ay nagrerehistro ng route na may handler. Ang sql.Open ay nagbubukas ng SQLite database, ang db.Query ay nagpapatakbo ng query. Ang c.JSON ay nagse-serialize ng slice posts sa JSON array. Ang anonymous function sa loob ng GET ay kumukuha ng db mula sa external na context. Hinahawakan ng Gin ang panic, nagla-log ng request at sumusuporta sa middleware.

Microservices at API gateways sa Go

Go — pangunahing wika para sa microservices architecture. Ang mababang memory consumption bawat microservice (15–30 MB) ay nagpapahintulot sa pagpapatakbo ng dose-dosenang serbisyo sa isang server. Ang mabilis na pagsisimula (milliseconds) at maliit na binary size (10–20 MB) ay nagpapasimple ng deployment sa containers.

Ang API gateway sa Go ay nagsasama-sama ng mga request mula sa mobile app patungo sa internal na serbisyo. Ang Golang gateway ay humahawak ng authentication (JWT), rate limiting, routing at caching. Sikat na implementations: Kong (batay sa OpenResty at Go plugins), Tyk (sa Go), sariling gateways sa Gin.

gRPC at protobuf

gRPC — remote procedure call framework mula sa Google, gamit ang Protocol Buffers para sa serialization at HTTP/2 para sa transport. Ang Go ay may pinakamahusay na gRPC support sa lahat ng wika. Para sa mobile backend, ang gRPC ay nagbibigay ng 5–10 beses na mas mataas na throughput kaysa 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))
}

Ang pb.UnimplementedUserServiceServer — isang stub na binuo ng protoc mula sa .proto file. Ang structure server ay nag-o-override sa method GetUser. Ang grpc.NewServer() ay lumilikha ng server na may interceptors para sa logging, authentication at metrics.

Go para sa CLI kagamitan at developer tools

Go — pinakamahusay na wika para sa CLI kagamitan na ginagamit sa mobile development. Isang static binary (~10 MB) na walang dependencies ay gumagana sa lahat ng platform: macOS, Linux, Windows. Ang compilation ay tumatagal ng mga segundo. Ang Go kagamitan ay hindi nangangailangan ng pag-install ng interpreter o runtime.

Halimbawa ng Go tools sa mobile ecosystem: Migrate (DB migrations), Kubectl (Kubernetes para sa mobile backend), Terraform (infrastructure), Prometheus (monitoring). Ang mga developer ay sumusulat ng Go kagamitan para sa pagbuo ng models mula sa proto files, validation ng configurations at deployment ng microservices.

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("Paggamit: deploy --project=path [--version=x.x.x]")
		os.Exit(1)
	}

	if *verbose {
		fmt.Printf("Nagde-deploy ng proyekto %s bersyon %s
", *project, *version)
	}
	// narito ang deployment logic
	fmt.Println("Kumpleto ang deployment")
}

Ang flag.String ay tumutukoy ng string flag ng command line na may pangalan, default value at paglalarawan. Ang flag.Parse() ay nagpa-parse ng mga argumento ng os.Args. Ang mga pointer *project ay dina-dereference para makuha ang mga value. Ang binary ay binuo gamit ang command na go build -o deploy deploy.go.

Gomobile: Go sa native library para sa iOS at Android

Gomobile — tool ng Google para sa pag-compile ng Go code sa native mobile library. Ang go bind -target=android ay bumubuo ng .aar para sa Android, ang go bind -target=ios ay bumubuo ng .xcframework para sa iOS. Ito ay nagpapahintulot sa pagsulat ng shared business logic sa Go at pagtawag nito mula sa Kotlin at Swift.

Pangunahing senaryo ng Gomobile: cryptography (sariling encryption schemes), pagtatrabaho sa network (sariling protocol sa pamamagitan ng WebSocket), pagproseso ng data (compression, encoding, parsing). Ang UI ay hindi isinusulat sa Go — ang gawain nito ay palitan ang C++ para sa cross-platform native modules.

package mobile

import "crypto/aes"

// EncryptData ay nag-e-encrypt ng AES-256-GCM data (ini-export sa .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
}

Ang mga na-export na function (na may malaking titik) ay binabalot ng Gomobile sa Java/Swift interface. Mula sa Kotlin ang tawag ay mukhang Mobile.encryptData(key, plaintext). Awtomatikong kino-convert ng Gomobile ang mga type: []byte → byte[] (Java) / Data (Swift).

Go laban sa Java at Kotlin para sa backend: paghahambing

Go ay nakikipagkumpitensya sa Java at Kotlin sa server development. Pangunahing pagkakaiba: nagko-compile ang Go sa native binary, hindi nangangailangan ng JVM, kumukonsumo ng 2–3 beses na mas kaunting memory at nagsisimula sa milliseconds. Panalo ang Java sa kapanahunan ng ecosystem at dami ng library.

Pinipili ang Go para sa microservices, API gateways at tools. Java/Kotlin — para sa enterprise applications na may mayaman na business logic. Sa mobile development, optimal na kombinasyon: Go para sa backend, Kotlin/Swift para sa client.