Go pentru dezvoltare mobilă: partea de server, API și utilitare

Ce este Go?

Go — un limbaj compilat cu tipizare statică și gestionare automată a memoriei prin garbage collector. Principalele scopuri ale Go: compilare rapidă, simplitate a codului și suport încorporat pentru concurență. Go se compilează într-un binar nativ fără mașină virtuală — un singur fișier executabil conține totul, inclusiv dependențele.

Biblioteca standard Go acoperă server HTTP, marshaling JSON, parsarea flagurilor de linie de comandă, criptare și lucrul cu baze de date. Pentru serverul HTTP nu este nevoie de un framework extern — net/http este încorporat. Go Modules (de la versiunea 1.16) — sistemul standard de gestionare a dependențelor. Versiunea actuală — Go 1.23 (2025) cu pachetul iter îmbunătățit pentru iteratori.

Go a fost proiectat pentru a rezolva problemele de scalare cu care s-a confruntat Google: compilarea lentă a C++, complexitatea Java, concurența ineficientă a Python. Rezultatul — un limbaj în care sunt scrise Docker, Kubernetes, Prometheus, Terraform și Hugo.

Sintaxa Go

Go este minimalist: 25 de cuvinte cheie (spre comparație C++ are 84). Nu există clase, moștenire, generice (până la versiunea 1.18), supraîncărcare a operatorilor și excepții. Erorile sunt gestionate explicit prin returnarea err. Structurile și interfețele înlocuiesc 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 pe :8080")
	http.ListenAndServe(":8080", nil)
}

Structura User cu tag-uri JSON definește serializarea. http.HandleFunc înregistrează un handler. json.NewEncoder(w).Encode(user) serializează structura direct în JSON în răspuns. Serverul HTTP încorporat procesează cererile automat în gorutine separate.

Gorutine și canale: modelul de concurență Go

Goroutines — fire de execuție ușoare gestionate de runtime-ul Go. Spre deosebire de firele OS (1–8 MB stivă), o gorutină pornește cu 4 KB stivă care crește dinamic. Se pot rula 100 000 de gorutine pe un singur server. Lansarea unei gorutine — go functionName().

Canalele (channels) — cozi tipizate pentru transmiterea datelor între gorutine. Un canal se creează prin make(chan Type). Operatorul <- trimite date, <-chan primește. Canalele pot fi bufferate (cu capacitate) și nebufferate (sincrone).

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

Trei cereri sunt executate paralel prin go fetchURL. Canalul ch colectează rezultatele. defer resp.Body.Close() garantează închiderea răspunsului la returnarea din funcție. select {} nu este folosit deoarece toate gorutinele trimit în canal — firul principal citește exact de len(urls) ori.

Go pentru partea de server a aplicațiilor mobile

Go — unul dintre cele mai bune limbaje pentru backend-ul aplicațiilor mobile. HTTP/2 și HTTP/3 încorporate, serializarea rapidă protobuf/gRPC și consumul redus de memorie fac Go ideal pentru API-uri care deservesc mii de clienți mobili.

Framework-uri populare: Gin (de până la 10x mai rapid decât Express.js), Echo (minimalist, JWT middleware), Fiber (în stilul Express), Chi (compatibil cu net/http). Gin este cel mai popular cu 70k+ stele pe GitHub. Pentru gRPC se folosește 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 înregistrează o rută cu handler. sql.Open deschide o bază de date SQLite, db.Query execută o interogare. c.JSON serializează slice-ul posts într-un array JSON. Funcția anonimă din interiorul GET captează db din contextul extern. Gin gestionează panic, loghează cererile și suportă middleware.

Microservicii și gateway-uri API în Go

Go — limbajul principal pentru arhitectura microserviciilor. Consumul redus de memorie per microserviciu (15–30 MB) permite rularea a zeci de servicii pe un singur server. Pornirea rapidă (milisecunde) și dimensiunea mică a binarului (10–20 MB) simplifică implementarea în containere.

Un gateway API în Go agregă cererile de la aplicația mobilă către serviciile interne. Gateway-ul Golang gestionează autentificarea (JWT), limitarea ratei, rutarea și stocarea în cache. Implementări populare: Kong (bazat pe OpenResty și plugin-uri Go), Tyk (în Go), gateway-uri proprii în Gin.

gRPC și protobuf

gRPC — un framework de apelare a procedurilor la distanță de la Google, care utilizează Protocol Buffers pentru serializare și HTTP/2 pentru transport. Go are cea mai bună suportare gRPC dintre toate limbajele. Pentru backend-ul mobil, gRPC asigură o capacitate de transmisie de 5–10 ori mai mare decât 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 — un stub generat de protoc din fișierul .proto. Structura server suprascrie metoda GetUser. grpc.NewServer() creează un server cu interceptoare pentru logare, autentificare și metrici.

Go pentru utilitare CLI și instrumente de dezvoltare

Go — cel mai bun limbaj pentru utilitare CLI utilizate în dezvoltarea mobilă. Un singur binar static (~10 MB) fără dependențe funcționează pe toate platformele: macOS, Linux, Windows. Compilarea durează secunde. Utilitarele Go nu necesită instalarea unui interpretor sau runtime.

Exemple de instrumente Go în ecosistemul mobil: Migrate (migrări BD), Kubectl (Kubernetes pentru backend mobil), Terraform (infrastructură), Prometheus (monitorizare). Dezvoltatorii scriu utilitare Go pentru generarea modelelor din fișiere proto, validarea configurațiilor și implementarea microserviciilor.

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

	if *verbose {
		fmt.Printf("Implementare proiect %s versiunea %s
", *project, *version)
	}
	// aici logica de implementare
	fmt.Println("Implementare completă")
}

flag.String definește un flag șir de linie de comandă cu nume, valoare implicită și descriere. flag.Parse() parsează argumentele os.Args. Pointerii *project sunt dereferențiați pentru a obține valorile. Binarul se construiește cu comanda go build -o deploy deploy.go.

Gomobile: Go în biblioteci native pentru iOS și Android

Gomobile — instrumentul Google pentru compilarea codului Go în biblioteci native mobile. go bind -target=android generează .aar pentru Android, go bind -target=ios — .xcframework pentru iOS. Acest lucru permite scrierea logicii de business comune în Go și apelarea ei din Kotlin și Swift.

Scenarii principale Gomobile: criptografie (scheme proprii de criptare), lucrul cu rețeaua (protocol propriu peste WebSocket), procesarea datelor (comprimare, codificare, parsare). UI nu se scrie în Go — sarcina sa este să înlocuiască C++ pentru module native cross-platform.

package mobile

import "crypto/aes"

// EncryptData criptează datele AES-256-GCM (exportat în .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
}

Funcțiile exportate (cu majusculă) sunt încapsulate de Gomobile în interfața Java/Swift. Din Kotlin apelul arată ca Mobile.encryptData(key, plaintext). Gomobile convertește automat tipurile: []byte → byte[] (Java) / Data (Swift).

Go vs Java și Kotlin pentru backend: comparație

Go concurează cu Java și Kotlin în dezvoltarea serverelor. Diferențe cheie: Go se compilează într-un binar nativ, nu necesită JVM, consumă de 2–3 ori mai puțină memorie și pornește în milisecunde. Java câștigă în maturitatea ecosistemului și numărul de biblioteci.

Go este ales pentru microservicii, gateway-uri API și instrumente. Java/Kotlin — pentru aplicații enterprise cu logică de business complexă. În dezvoltarea mobilă, combinația optimă: Go pentru backend, Kotlin/Swift pentru client.