Go mobil fejlesztéshez: szerver oldal, API-k és segédprogramok

Mi az a Go?

Go — statikusan típusos, fordított nyelv automatikus memóriakezeléssel szemétgyűjtőn keresztül. A Go fő céljai: gyors fordítás, kód egyszerűsége és beépített konkurencia támogatás. A Go natív bináris fájlba fordul virtuális gép nélkül — egy végrehajtható fájl mindent tartalmaz, beleértve a függőségeket is.

A Go szabványos könyvtára lefedi a HTTP szervert, JSON marshalingot, parancssori zászlók feldolgozását, titkosítást és adatbázisokkal való munkát. A HTTP szerverhez nincs szükség külső keretrendszerre — a net/http beépített. Go Modules (1.16 verziótól) — a függőségkezelés szabványos rendszere. Jelenlegi verzió — Go 1.23 (2025) továbbfejlesztett iter csomaggal.

A Go-t a Google skálázási problémáinak megoldására tervezték: a C++ lassú fordítása, a Java komplexitása, a Python nem hatékony konkurenciája. Eredmény — a nyelv, amelyen a Docker, Kubernetes, Prometheus, Terraform és Hugo íródott.

A Go szintaxisa

A Go minimalista: 25 kulcsszó (összehasonlításképp a C++ 84). Nincsenek osztályok, öröklődés, generikusok (1.18 verzióig), operátor túlterhelés és kivételek. A hibák explicit módon kezelődnek az err visszaadásával. A struktúrák és interfészek helyettesítik az OOP-t.

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("Szerver a :8080-on")
	http.ListenAndServe(":8080", nil)
}

A User struktúra JSON címkékkel határozza meg a szerializációt. Az http.HandleFunc regisztrál egy kezelőt. A json.NewEncoder(w).Encode(user) szerializálja a struktúrát közvetlenül JSON-ba a válaszban. A beépített HTTP szerver automatikusan külön gorutinokban dolgozza fel a kéréseket.

Goroutines és csatornák: a Go konkurencia modellje

Goroutines — a Go futásidejű környezete által kezelt könnyű végrehajtási szálak. Az OS szálaktól (1–8 MB verem) eltérően a gorutin 4 KB veremmel indul, amely dinamikusan nő. 100 000 gorutin futtatható egy szerveren. Gorutin indítása — go functionName().

Csatornák (channels) — típusos sorok adatok átviteléhez gorutinok között. Csatorna a make(chan Type) segítségével hozható létre. A <- operátor adatot küld, a <-chan fogad. A csatornák lehetnek pufferelt (kapacitással) és nem pufferelt (szinkron).

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

Három kérés párhuzamosan hajtódik végre a go fetchURL segítségével. A ch csatorna gyűjti az eredményeket. A defer resp.Body.Close() garantálja a válasz bezárását a függvényből való visszatéréskor. A select {} nem használatos, mert minden gorutin a csatornába küld — a fő szál pontosan len(urls) alkalommal olvas.

Go mobil alkalmazások szerver oldalához

Go — az egyik legjobb nyelv a mobil alkalmazások backendjéhez. A beépített HTTP/2 és HTTP/3, gyors protobuf/gRPC szerializáció és alacsony memóriafogyasztás ideálissá teszik a Go-t olyan API-khoz, amelyek több ezer mobil klienst szolgálnak ki.

Népszerű keretrendszerek: Gin (akár 10x gyorsabb, mint az Express.js), Echo (minimalista, JWT middleware), Fiber (Express stílusban), Chi (kompatibilis a net/http-val). A Gin a legnépszerűbb 70k+ csillaggal a GitHub-on. gRPC-hez a google.golang.org/grpc használatos.

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")
}

A Gin.GET regisztrál egy útvonalat kezelővel. Az sql.Open megnyit egy SQLite adatbázist, a db.Query végrehajt egy lekérdezést. A c.JSON szerializálja a posts szeletet JSON tömbbé. A GET-en belüli névtelen függvény elkapja a db-t a külső kontextusból. A Gin kezeli a panikot, naplózza a kéréseket és támogatja a middleware-t.

Mikroszolgáltatások és API-átjárók Go-ban

Go — a fő nyelv a mikroszolgáltatás architektúrához. Az alacsony memóriafogyasztás mikroszolgáltatásonként (15–30 MB) lehetővé teszi több tucat szolgáltatás futtatását egy szerveren. A gyors indítás (ezredmásodpercek) és a kis bináris méret (10–20 MB) leegyszerűsíti a konténerekbe történő telepítést.

Egy API-átjáró Go-ban összesíti a mobil alkalmazás kéréseit a belső szolgáltatásokhoz. A Golang-átjáró kezeli a hitelesítést (JWT), sebességkorlátozást, útválasztást és gyorsítótárazást. Népszerű megvalósítások: Kong (OpenResty és Go bővítményeken alapuló), Tyk (Go-ban), saját átjárók Gin-ben.

gRPC és protobuf

gRPC — távoli eljáráshívó keretrendszer a Google-tól, amely a Protocol Buffers-t használja szerializációhoz és a HTTP/2-t szállításhoz. A Go rendelkezik a legjobb gRPC támogatással az összes nyelv közül. Mobil backend esetén a gRPC 5–10-szer nagyobb átviteli sebességet biztosít, mint a 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 — a protoc által a .proto fájlból generált csonk. A server struktúra felülírja a GetUser metódust. A grpc.NewServer() szervert hoz létre naplózási, hitelesítési és metrikai elfogókkal.

Go CLI segédprogramokhoz és fejlesztői eszközökhöz

Go — a legjobb nyelv a mobil fejlesztésben használt CLI segédprogramokhoz. Egyetlen statikus bináris fájl (~10 MB) függőségek nélkül működik minden platformon: macOS, Linux, Windows. A fordítás másodpercekig tart. A Go segédprogramok nem igényelnek értelmező vagy futásidejű környezet telepítését.

Példák Go eszközökre a mobil ökoszisztémában: Migrate (adatbázis migrációk), Kubectl (Kubernetes mobil backendhez), Terraform (infrastruktúra), Prometheus (monitorozás). A fejlesztők Go segédprogramokat írnak modellek generálásához proto fájlokból, konfigurációk érvényesítéséhez és mikroszolgáltatások telepítéséhez.

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

	if *verbose {
		fmt.Printf("%s projekt %s verzió telepítése
", *project, *version)
	}
	// itt a telepítési logika
	fmt.Println("Telepítés kész")
}

A flag.String egy karakterlánc típusú parancssori zászlót határoz meg névvel, alapértelmezett értékkel és leírással. A flag.Parse() feldolgozza az os.Args argumentumait. A *project mutatók dereferálódnak az értékek lekéréséhez. A bináris fájl a go build -o deploy deploy.go paranccsal épül.

Gomobile: Go natív könyvtárakban iOS és Android rendszerhez

Gomobile — a Google eszköze a Go kód natív mobil könyvtárakba fordításához. A go bind -target=android .aar fájlt generál Androidhoz, a go bind -target=ios .xcframework fájlt iOS-hez. Ez lehetővé teszi közös üzleti logika írását Go-ban és annak Kotlinból és Swiftből történő meghívását.

A Gomobile fő forgatókönyvei: kriptográfia (saját titkosítási sémák), hálózati munka (saját protokoll WebSocketen keresztül), adatfeldolgozás (tömörítés, kódolás, feldolgozás). UI-t nem írnak Go-ban — feladata a C++ helyettesítése többplatformos natív modulokhoz.

package mobile

import "crypto/aes"

// EncryptData AES-256-GCM adatokat titkosít (.aar-ba exportálva)
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
}

Az exportált függvényeket (nagybetűvel) a Gomobile Java/Swift interfészbe csomagolja. Kotlinból a hívás Mobile.encryptData(key, plaintext) formában néz ki. A Gomobile automatikusan konvertálja a típusokat: []byte → byte[] (Java) / Data (Swift).

Go vs Java és Kotlin backendhez: összehasonlítás

Go versenyez a Java-val és Kotlinnel a szerver oldali fejlesztésben. Fő különbségek: a Go natív bináris fájlba fordul, nem igényel JVM-et, 2–3-szor kevesebb memóriát fogyaszt és ezredmásodpercek alatt indul. A Java az ökoszisztéma érettségében és a könyvtárak számában győz.

A Go-t mikroszolgáltatásokhoz, API-átjárókhoz és eszközökhöz választják. Java/Kotlin — gazdag üzleti logikával rendelkező vállalati alkalmazásokhoz. Mobil fejlesztésben az optimális kombináció: Go a backendhez, Kotlin/Swift a klienshez.