Go w rozwoju mobilnym: część serwerowa, API i narzędzia

Czym jest Go?

Go — statycznie typowany kompilowany język z automatycznym zarządzaniem pamięcią przez garbage collector. Główne cele Go: szybka kompilacja, prostota kodu i wbudowane wsparcie dla współbieżności. Go kompiluje się do natywnego pliku binarnego bez maszyny wirtualnej — jeden plik wykonywalny zawiera wszystko, łącznie z zależnościami.

Standardowa biblioteka Go obejmuje serwer HTTP, marshaling JSON, parsowanie flag linii poleceń, szyfrowanie i pracę z bazami danych. Do serwera HTTP nie potrzeba zewnętrznego frameworka — net/http jest wbudowany. Go Modules (od wersji 1.16) — standardowy system zarządzania zależnościami. Aktualna wersja — Go 1.23 (2025) z ulepszonym pakietem iter dla iteratorów.

Go został zaprojektowany do rozwiązywania problemów skalowania, z którymi zetknął się Google: wolna kompilacja C++, złożoność Java, nieefektywna współbieżność Python. Rezultat — język, w którym napisano Docker, Kubernetes, Prometheus, Terraform i Hugo.

Składnia Go

Go jest minimalistyczny: 25 słów kluczowych (dla porównania C++ ma 84). Brak klas, dziedziczenia, generyków (do wersji 1.18), przeciążania operatorów i wyjątków. Błędy są obsługiwane jawnie przez zwracanie err. Struktury i interfejsy zastępują 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("Serwer na :8080")
	http.ListenAndServe(":8080", nil)
}

Struktura User z tagami JSON określa serializację. http.HandleFunc rejestruje handler. json.NewEncoder(w).Encode(user) serializuje strukturę do JSON bezpośrednio w odpowiedzi. Wbudowany serwer HTTP obsługuje żądania w osobnych gorutynach automatycznie.

Goroutines i kanały: model współbieżności Go

Goroutines — lekkie wątki wykonawcze zarządzane przez runtime Go. W przeciwieństwie do wątków OS (1–8 MB stosu), gorutyna startuje z 4 KB stosu, który dynamicznie rośnie. Można uruchomić 100 000 gorutyn na jednym serwerze. Uruchomienie gorutyny — go functionName().

Kanały (channels) — typizowane kolejki do przesyłania danych między gorutynami. Kanał tworzy się przez make(chan Type). Operator <- wysyła dane, <-chan odbiera. Kanały mogą być buforowane (z pojemnością) i niebuforowane (synchroniczne).

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("Błąd: %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)
	}
}

Trzy żądania są wykonywane równolegle przez go fetchURL. Kanał ch zbiera wyniki. defer resp.Body.Close() gwarantuje zamknięcie odpowiedzi przy powrocie z funkcji. select {} nie jest używany, ponieważ wszystkie gorutyny wysyłają do kanału — główny wątek czyta dokładnie len(urls) razy.

Go dla części serwerowej aplikacji mobilnych

Go — jeden z najlepszych języków dla backendu aplikacji mobilnych. Wbudowany HTTP/2 i HTTP/3, szybka serializacja protobuf/gRPC i niskie zużycie pamięci czynią Go idealnym dla API obsługujących tysiące klientów mobilnych.

Popularne frameworki: Gin (do 10x szybszy od Express.js), Echo (minimalistyczny, JWT middleware), Fiber (w stylu Express), Chi (kompatybilny z net/http). Gin jest najpopularniejszy z 70k+ gwiazdkami na GitHub. Do gRPC używa się 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 rejestruje trasę z handlerem. sql.Open otwiera bazę SQLite, db.Query wykonuje zapytanie. c.JSON serializuje slice posts do tablicy JSON. Funkcja anonimowa wewnątrz GET przechwytuje db z zewnętrznego kontekstu. Gin obsługuje panic, loguje żądania i wspiera middleware.

Mikrousługi i bramy API w Go

Go — główny język dla architektury mikrousług. Niskie zużycie pamięci na mikrousługę (15–30 MB) pozwala uruchamiać dziesiątki usług na jednym serwerze. Szybki start (milisekundy) i mały rozmiar pliku binarnego (10–20 MB) upraszczają wdrażanie w kontenerach.

Brama API w Go agreguje żądania z aplikacji mobilnej do wewnętrznych usług. Brama Golang obsługuje uwierzytelnianie (JWT), rate limiting, routing i buforowanie. Popularne implementacje: Kong (oparty na OpenResty i wtyczkach Go), Tyk (w Go), własne bramy na Gin.

gRPC i protobuf

gRPC — framework zdalnego wywoływania procedur od Google, używający Protocol Buffers do serializacji i HTTP/2 do transportu. Go ma najlepsze wsparcie gRPC spośród wszystkich języków. Dla mobilnego backendu gRPC zapewnia 5–10 razy wyższą przepustowość niż 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 — zaślepka wygenerowana przez protoc z pliku .proto. Struktura server nadpisuje metodę GetUser. grpc.NewServer() tworzy serwer z przechwytami do logowania, uwierzytelniania i metryk.

Go dla narzędzi CLI i instrumentów deweloperskich

Go — najlepszy język dla narzędzi CLI używanych w rozwoju mobilnym. Jeden statyczny plik binarny (~10 MB) bez zależności działa na wszystkich platformach: macOS, Linux, Windows. Kompilacja zajmuje sekundy. Narzędzia Go nie wymagają instalacji interpretera ani runtime'u.

Przykłady narzędzi Go w ekosystemie mobilnym: Migrate (migracje BD), Kubectl (Kubernetes dla mobilnego backendu), Terraform (infrastruktura), Prometheus (monitoring). Deweloperzy piszą narzędzia Go do generowania modeli z plików proto, walidacji konfiguracji i wdrażania mikrousług.

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

	if *verbose {
		fmt.Printf("Wdrażanie projektu %s wersja %s
", *project, *version)
	}
	// tutaj logika wdrożenia
	fmt.Println("Wdrożenie zakończone")
}

flag.String definiuje flagę łańcuchową linii poleceń z nazwą, wartością domyślną i opisem. flag.Parse() parsuje argumenty os.Args. Wskaźniki *project są dereferencjonowane do pobrania wartości. Plik binarny buduje się komendą go build -o deploy deploy.go.

Gomobile: Go w natywnych bibliotekach dla iOS i Android

Gomobile — narzędzie Google do kompilacji kodu Go do natywnych bibliotek mobilnych. go bind -target=android generuje .aar dla Androida, go bind -target=ios — .xcframework dla iOS. Pozwala to pisać wspólną logikę biznesową w Go i wywoływać ją z Kotlin i Swift.

Główne scenariusze Gomobile: kryptografia (własne schematy szyfrowania), praca z siecią (własny protokół przez WebSocket), przetwarzanie danych (kompresja, kodowanie, parsowanie). UI w Go się nie pisze — jego zadaniem jest zastąpić C++ dla wieloplatformowych modułów natywnych.

package mobile

import "crypto/aes"

// EncryptData szyfruje dane AES-256-GCM (eksportowane 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
}

Eksportowane funkcje (z dużej litery) Gomobile opakowuje w interfejs Java/Swift. Z Kotlin wywołanie wygląda jak Mobile.encryptData(key, plaintext). Gomobile automatycznie konwertuje typy: []byte → byte[] (Java) / Data (Swift).

Go vs Java i Kotlin dla backendu: porównanie

Go konkuruje z Java i Kotlin w rozwoju serwerowym. Kluczowe różnice: Go kompiluje się do natywnego pliku binarnego, nie wymaga JVM, zużywa 2–3 razy mniej pamięci i uruchamia się w milisekundach. Java wygrywa w dojrzałości ekosystemu i liczbie bibliotek.

Go wybiera się do mikrousług, bram API i narzędzi. Java/Kotlin — do aplikacji enterprise z bogatą logiką biznesową. W rozwoju mobilnym optymalny zestaw: Go dla backendu, Kotlin/Swift dla klienta.