Go voor mobiele ontwikkeling: serverkant, API's en hulpprogramma's

Wat is Go?

Go — een statisch getypeerde gecompileerde taal met automatisch geheugenbeheer via een garbage collector. De belangrijkste doelen van Go: snelle compilatie, eenvoud van code en ingebouwde ondersteuning voor concurrentie. Go wordt gecompileerd naar een native binair bestand zonder virtuele machine — één uitvoerbaar bestand bevat alles, inclusief afhankelijkheden.

De standaardbibliotheek van Go omvat HTTP-server, JSON-marshalling, parseren van commandoregelflags, encryptie en werken met databases. Voor een HTTP-server is geen extern framework nodig — net/http is ingebouwd. Go Modules (sinds versie 1.16) — het standaard systeem voor afhankelijkheidsbeheer. Huidige versie — Go 1.23 (2025) met verbeterd iter-pakket voor iterators.

Go is ontworpen om de schaalproblemen van Google op te lossen: trage compilatie van C++, complexiteit van Java, inefficiënte concurrentie van Python. Het resultaat — een taal waarin Docker, Kubernetes, Prometheus, Terraform en Hugo zijn geschreven.

Syntaxis van Go

Go is minimalistisch: 25 trefwoorden (ter vergelijking C++ heeft er 84). Geen klassen, overerving, generics (tot versie 1.18), operator overloading en uitzonderingen. Fouten worden expliciet afgehandeld via het retourneren van err. Structuren en interfaces vervangen 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 op :8080")
	http.ListenAndServe(":8080", nil)
}

De structuur User met JSON-tags definieert serialisatie. http.HandleFunc registreert een handler. json.NewEncoder(w).Encode(user) serialiseert de structuur direct naar JSON in het antwoord. De ingebouwde HTTP-server verwerkt verzoeken automatisch in aparte goroutines.

Goroutines en kanalen: het concurrentiemodel van Go

Goroutines — lichte uitvoeringsthreads beheerd door de Go-runtime. In tegenstelling tot OS-threads (1–8 MB stack), start een goroutine met 4 KB stack die dynamisch groeit. Je kunt 100.000 goroutines op één server draaien. Een goroutine starten — go functionName().

Kanalen (channels) — getypeerde wachtrijen voor gegevensoverdracht tussen goroutines. Een kanaal wordt gemaakt via make(chan Type). De operator <- verzendt gegevens, <-chan ontvangt. Kanalen kunnen gebufferd (met capaciteit) en ongebufferd (synchroon) zijn.

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

Drie verzoeken worden parallel uitgevoerd via go fetchURL. Het kanaal ch verzamelt de resultaten. defer resp.Body.Close() garandeert het sluiten van de respons bij terugkeer uit de functie. select {} wordt niet gebruikt omdat alle goroutines naar het kanaal sturen — de hoofdthread leest precies len(urls) keer.

Go voor de serverkant van mobiele applicaties

Go — een van de beste talen voor de backend van mobiele applicaties. Ingebouwde HTTP/2 en HTTP/3, snelle protobuf/gRPC-serialisatie en laag geheugengebruik maken Go ideaal voor API's die duizenden mobiele clients bedienen.

Populaire frameworks: Gin (tot 10x sneller dan Express.js), Echo (minimalistisch, JWT middleware), Fiber (in de stijl van Express), Chi (compatibel met net/http). Gin is het populairst met 70k+ sterren op GitHub. Voor gRPC wordt google.golang.org/grpc gebruikt.

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 registreert een route met een handler. sql.Open opent een SQLite-database, db.Query voert een query uit. c.JSON serialiseert de slice posts naar een JSON-array. De anonieme functie binnenin GET vangt db op uit de externe context. Gin handelt panic af, logt verzoeken en ondersteunt middleware.

Microservices en API-gateways in Go

Go — de belangrijkste taal voor microservices-architectuur. Laag geheugengebruik per microservice (15–30 MB) maakt het mogelijk om tientallen services op één server te draaien. Snelle start (milliseconden) en klein binair bestand (10–20 MB) vereenvoudigen implementatie in containers.

Een API-gateway in Go aggregeert verzoeken van de mobiele app naar interne services. De Golang-gateway handelt authenticatie (JWT), rate limiting, routering en caching af. Populaire implementaties: Kong (gebaseerd op OpenResty en Go-plugins), Tyk (in Go), eigen gateways in Gin.

gRPC en protobuf

gRPC — een framework voor externe procedureaanroepen van Google, dat Protocol Buffers gebruikt voor serialisatie en HTTP/2 voor transport. Go heeft de beste gRPC-ondersteuning van alle talen. Voor mobiele backend biedt gRPC een 5–10 keer hogere doorvoer dan 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 — een stub gegenereerd door protoc uit het .proto-bestand. De structuur server overschrijft de methode GetUser. grpc.NewServer() creëert een server met interceptors voor logging, authenticatie en metrieken.

Go voor CLI-hulpprogramma's en ontwikkeltools

Go — de beste taal voor CLI-hulpprogramma's gebruikt in mobiele ontwikkeling. Eén statisch binair bestand (~10 MB) zonder afhankelijkheden werkt op alle platforms: macOS, Linux, Windows. Compilatie duurt seconden. Go-hulpprogramma's vereisen geen installatie van een interpreter of runtime.

Voorbeelden van Go-tools in het mobiele ecosysteem: Migrate (DB-migraties), Kubectl (Kubernetes voor mobiele backend), Terraform (infrastructuur), Prometheus (monitoring). Ontwikkelaars schrijven Go-hulpprogramma's voor het genereren van modellen uit proto-bestanden, validatie van configuraties en implementatie van 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("Gebruik: deploy --project=path [--version=x.x.x]")
		os.Exit(1)
	}

	if *verbose {
		fmt.Printf("Project %s versie %s implementeren
", *project, *version)
	}
	// hier implementatielogica
	fmt.Println("Implementatie voltooid")
}

flag.String definieert een string-flag van de commandoregel met naam, standaardwaarde en beschrijving. flag.Parse() parseert de argumenten van os.Args. Pointers *project worden gederefereerd om waarden te verkrijgen. Het binaire bestand wordt gebouwd met het commando go build -o deploy deploy.go.

Gomobile: Go in native bibliotheken voor iOS en Android

Gomobile — de tool van Google voor het compileren van Go-code naar native mobiele bibliotheken. go bind -target=android genereert .aar voor Android, go bind -target=ios genereert .xcframework voor iOS. Dit maakt het mogelijk om gemeenschappelijke bedrijfslogica in Go te schrijven en aan te roepen vanuit Kotlin en Swift.

Belangrijkste Gomobile-scenario's: cryptografie (eigen encryptieschema's), netwerkwerk (eigen protocol via WebSocket), gegevensverwerking (compressie, codering, parsing). UI wordt niet in Go geschreven — de taak is om C++ te vervangen voor cross-platform native modules.

package mobile

import "crypto/aes"

// EncryptData versleutelt AES-256-GCM-gegevens (geëxporteerd naar .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
}

Geëxporteerde functies (met hoofdletter) worden door Gomobile verpakt in een Java/Swift-interface. Vanuit Kotlin ziet de aanroep eruit als Mobile.encryptData(key, plaintext). Gomobile converteert automatisch types: []byte → byte[] (Java) / Data (Swift).

Go versus Java en Kotlin voor backend: vergelijking

Go concurreert met Java en Kotlin in serverontwikkeling. Belangrijkste verschillen: Go wordt gecompileerd naar een native binair bestand, heeft geen JVM nodig, verbruikt 2–3 keer minder geheugen en start in milliseconden. Java wint in volwassenheid van het ecosysteem en aantal bibliotheken.

Go wordt gekozen voor microservices, API-gateways en tools. Java/Kotlin — voor enterprise-applicaties met rijke bedrijfslogica. In mobiele ontwikkeling is de optimale combinatie: Go voor de backend, Kotlin/Swift voor de client.