Go pro mobilní vývoj: serverová část, API a nástroje

Co je Go?

Go — staticky typovaný kompilovaný jazyk s automatickou správou paměti pomocí garbage collectoru. Hlavní cíle Go: rychlá kompilace, jednoduchost kódu a vestavěná podpora konkurence. Go se kompiluje do nativního binárního souboru bez virtuálního stroje — jeden spustitelný soubor obsahuje vše včetně závislostí.

Standardní knihovna Go pokrývá HTTP server, JSON marshaling, parsování příznaků příkazového řádku, šifrování a práci s databázemi. Pro HTTP server není potřeba externí framework — net/http je vestavěný. Go Modules (od verze 1.16) — standardní systém správy závislostí. Aktuální verze — Go 1.23 (2025) s vylepšeným balíčkem iter pro iterátory.

Go byl navržen k řešení problémů škálování, kterým čelil Google: pomalé kompilování C++, složitost Java, neefektivní konkurence Pythonu. Výsledek — jazyk, ve kterém jsou napsány Docker, Kubernetes, Prometheus, Terraform a Hugo.

Syntaxe Go

Go je minimalistický: 25 klíčových slov (pro srovnání C++ jich má 84). Chybí třídy, dědičnost, generika (do verze 1.18), přetěžování operátorů a výjimky. Chyby jsou zpracovávány explicitně návratem err. Struktury a rozhraní nahrazují 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 na :8080")
	http.ListenAndServe(":8080", nil)
}

Struktura User s JSON tagy definuje serializaci. http.HandleFunc registruje handler. json.NewEncoder(w).Encode(user) serializuje strukturu přímo do JSON v odpovědi. Vestavěný HTTP server zpracovává požadavky automaticky v oddělených gorutinách.

Gorutiny a kanály: model konkurence v Go

Goroutines — lehká prováděcí vlákna spravovaná runtime Go. Na rozdíl od OS vláken (zásobník 1–8 MB) gorutina startuje se zásobníkem 4 KB, který dynamicky roste. Na jednom serveru lze spustit 100 000 gorutin. Spuštění gorutiny — go functionName().

Kanály (channels) — typované fronty pro přenos dat mezi gorutinami. Kanál se vytváří přes make(chan Type). Operátor <- odesílá data, <-chan přijímá. Kanály mohou být bufferované (s kapacitou) a nebufferované (synchronní).

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

Tři požadavky jsou prováděny paralelně pomocí go fetchURL. Kanál ch shromažďuje výsledky. defer resp.Body.Close() garantuje uzavření odpovědi při návratu z funkce. select {} není použit, protože všechny gorutiny odesílají do kanálu — hlavní vlákno čte přesně len(urls) krát.

Go pro serverovou část mobilních aplikací

Go — jeden z nejlepších jazyků pro backend mobilních aplikací. Vestavěný HTTP/2 a HTTP/3, rychlá serializace protobuf/gRPC a nízká spotřeba paměti činí Go ideálním pro API obsluhující tisíce mobilních klientů.

Populární frameworky: Gin (až 10x rychlejší než Express.js), Echo (minimalistický, JWT middleware), Fiber (ve stylu Express), Chi (kompatibilní s net/http). Gin je nejpopulárnější s 70k+ hvězdičkami na GitHubu. Pro gRPC se používá 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 registruje trasu s handlrem. sql.Open otevírá SQLite databázi, db.Query provádí dotaz. c.JSON serializuje slice posts do JSON pole. Anonymní funkce uvnitř GET zachycuje db z vnějšího kontextu. Gin zpracovává panic, loguje požadavky a podporuje middleware.

Mikroslužby a API brány v Go

Go — hlavní jazyk pro mikroslužbovou architekturu. Nízká spotřeba paměti na mikroslužbu (15–30 MB) umožňuje provozovat desítky služeb na jednom serveru. Rychlý start (milisekundy) a malá velikost binárního souboru (10–20 MB) zjednodušují nasazení v kontejnerech.

API brána v Go agreguje požadavky z mobilní aplikace k interním službám. Golang brána zpracovává autentizaci (JWT), rate limiting, routování a caching. Populární implementace: Kong (založený na OpenResty a Go pluginech), Tyk (v Go), vlastní brány v Gin.

gRPC a protobuf

gRPC — framework pro vzdálené volání procedur od Google, používající Protocol Buffers pro serializaci a HTTP/2 pro transport. Go má nejlepší podporu gRPC ze všech jazyků. Pro mobilní backend poskytuje gRPC 5–10 krát vyšší propustnost než 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 generovaný protoc ze souboru .proto. Struktura server přepisuje metodu GetUser. grpc.NewServer() vytváří server s interceptory pro logování, autentizaci a metriky.

Go pro CLI nástroje a vývojářské nástroje

Go — nejlepší jazyk pro CLI nástroje používané v mobilním vývoji. Jeden statický binární soubor (~10 MB) bez závislostí funguje na všech platformách: macOS, Linux, Windows. Kompilace trvá sekundy. Go nástroje nevyžadují instalaci interpretru nebo runtime.

Příklady Go nástrojů v mobilním ekosystému: Migrate (migrace DB), Kubectl (Kubernetes pro mobilní backend), Terraform (infrastruktura), Prometheus (monitoring). Vývojáři píší Go nástroje pro generování modelů z proto souborů, validaci konfigurací a nasazování mikroslužeb.

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

	if *verbose {
		fmt.Printf("Nasazení projektu %s verze %s
", *project, *version)
	}
	// zde logika nasazení
	fmt.Println("Nasazení dokončeno")
}

flag.String definuje řetězcový příznak příkazového řádku se jménem, výchozí hodnotou a popisem. flag.Parse() parsuje argumenty os.Args. Ukazatele *project jsou dereferencovány pro získání hodnot. Binární soubor se sestavuje příkazem go build -o deploy deploy.go.

Gomobile: Go v nativních knihovnách pro iOS a Android

Gomobile — nástroj Google pro kompilaci kódu Go do nativních mobilních knihoven. go bind -target=android generuje .aar pro Android, go bind -target=ios generuje .xcframework pro iOS. To umožňuje psát společnou obchodní logiku v Go a volat ji z Kotlin a Swift.

Hlavní scénáře Gomobile: kryptografie (vlastní šifrovací schémata), práce se sítí (vlastní protokol přes WebSocket), zpracování dat (komprese, kódování, parsování). UI se v Go nepíše — jeho úkolem je nahradit C++ pro cross-platform nativní moduly.

package mobile

import "crypto/aes"

// EncryptData šifruje data AES-256-GCM (exportováno do .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
}

Exportované funkce (s velkým písmenem) Gomobile zabaluje do rozhraní Java/Swift. Z Kotlinu volání vypadá jako Mobile.encryptData(key, plaintext). Gomobile automaticky konvertuje typy: []byte → byte[] (Java) / Data (Swift).

Go vs Java a Kotlin pro backend: srovnání

Go konkuruje Javě a Kotlinu v serverovém vývoji. Klíčové rozdíly: Go se kompiluje do nativního binárního souboru, nevyžaduje JVM, spotřebovává 2–3 krát méně paměti a startuje v milisekundách. Java vítězí ve vyspělosti ekosystému a počtu knihoven.

Go je voleno pro mikroslužby, API brány a nástroje. Java/Kotlin — pro enterprise aplikace s bohatou obchodní logikou. V mobilním vývoji je optimální kombinace: Go pro backend, Kotlin/Swift pro klienta.