Go för mobil utveckling: serversida, API:er och verktyg

Vad är Go?

Go — ett statiskt typat kompilerat språk med automatisk minneshantering via en sopsamlare. Gos huvudmål: snabb kompilering, kodens enkelhet och inbyggt stöd för samtidighet. Go kompileras till en inbyggd binär utan virtuell maskin — en enda körbar fil innehåller allt, inklusive beroenden.

Gos standardbibliotek täcker HTTP-server, JSON-marshalling, tolkning av kommandoradsflaggor, kryptering och arbete med databaser. För HTTP-server behövs inget externt ramverk — net/http är inbyggt. Go Modules (från version 1.16) — standard system för beroendehantering. Nuvarande version — Go 1.23 (2025) med förbättrat iter-paket för iteratorer.

Go designades för att lösa skalningsproblem som Google stötte på: långsam kompilering av C++, komplexitet i Java, ineffektiv samtidighet i Python. Resultatet — ett språk som används för Docker, Kubernetes, Prometheus, Terraform och Hugo.

Gos syntax

Go är minimalistisk: 25 nyckelord (för jämförelse har C++ 84). Inga klasser, arv, generics (före version 1.18), operatörsöverlagring och undantag. Fel hanteras explicit genom att returnera err. Strukturer och gränssnitt ersätter 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 på :8080")
	http.ListenAndServe(":8080", nil)
}

Strukturen User med JSON-taggar definierar serialisering. http.HandleFunc registrerar en hanterare. json.NewEncoder(w).Encode(user) serialiserar strukturen direkt till JSON i svaret. Den inbyggda HTTP-servern behandlar förfrågningar automatiskt i separata gorutiner.

Goroutines och kanaler: Gos samtidighetsmodell

Goroutines — lätta exekveringstrådar som hanteras av Gos runtime. Till skillnad från OS-trådar (1–8 MB stack) startar en gorutin med 4 KB stack som växer dynamiskt. Man kan köra 100 000 gorutiner på en server. Starta en gorutin — go functionName().

Kanaler (channels) — typade köer för dataöverföring mellan gorutiner. En kanal skapas via make(chan Type). Operatorn <- skickar data, <-chan tar emot. Kanaler kan vara buffrade (med kapacitet) och obuffrade (synkrona).

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

Tre förfrågningar utförs parallellt via go fetchURL. Kanalen ch samlar in resultaten. defer resp.Body.Close() garanterar att svaret stängs vid återkomst från funktionen. select {} används inte eftersom alla gorutiner skickar till kanalen — huvudtråden läser exakt len(urls) gånger.

Go för serversidan av mobila applikationer

Go — ett av de bästa språken för backend av mobila applikationer. Inbyggd HTTP/2 och HTTP/3, snabb protobuf/gRPC-serialisering och låg minnesförbrukning gör Go idealiskt för API:er som betjänar tusentals mobila klienter.

Populära ramverk: Gin (upp till 10x snabbare än Express.js), Echo (minimalistiskt, JWT-mellanprogram), Fiber (i stil med Express), Chi (kompatibelt med net/http). Gin är mest populärt med 70k+ stjärnor på GitHub. För gRPC används 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 registrerar en rutt med en hanterare. sql.Open öppnar en SQLite-databas, db.Query utför en fråga. c.JSON serialiserar slice posts till en JSON-array. Den anonyma funktionen inuti GET fångar db från den externa kontexten. Gin hanterar panic, loggar förfrågningar och stöder mellanprogram.

Mikrotjänster och API-gateways i Go

Go — huvudspråket för mikrotjänstarkitektur. Låg minnesförbrukning per mikrotjänst (15–30 MB) gör det möjligt att köra dussintals tjänster på en server. Snabb start (millisekunder) och liten binär storlek (10–20 MB) förenklar driftsättning i containrar.

En API-gateway i Go aggregerar förfrågningar från mobilappen till interna tjänster. Golang-gatewayen hanterar autentisering (JWT), hastighetsbegränsning, routning och cachning. Populära implementeringar: Kong (baserat på OpenResty och Go-pluginar), Tyk (i Go), egna gateways i Gin.

gRPC och protobuf

gRPC — ramverk för fjärrproceduranrop från Google, som använder Protocol Buffers för serialisering och HTTP/2 för transport. Go har bäst gRPC-stöd bland alla språk. För mobil backend ger gRPC 5–10 gånger högre genomströmning än 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 — en stubbe som genereras av protoc från .proto-filen. Strukturen server åsidosätter metoden GetUser. grpc.NewServer() skapar en server med interceptorer för loggning, autentisering och mätvärden.

Go för CLI-verktyg och utvecklarverktyg

Go — det bästa språket för CLI-verktyg som används inom mobil utveckling. En enda statisk binär (~10 MB) utan beroenden fungerar på alla plattformar: macOS, Linux, Windows. Kompilering tar sekunder. Go-verktyg kräver ingen installation av tolk eller runtime.

Exempel på Go-verktyg i mobila ekosystemet: Migrate (databasmigreringar), Kubectl (Kubernetes för mobil backend), Terraform (infrastruktur), Prometheus (övervakning). Utvecklare skriver Go-verktyg för att generera modeller från proto-filer, validera konfigurationer och driftsätta mikrotjänster.

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

	if *verbose {
		fmt.Printf("Deployerar projekt %s version %s
", *project, *version)
	}
	// här deploymentslogik
	fmt.Println("Deployment slutförd")
}

flag.String definierar en strängflagga för kommandoraden med namn, standardvärde och beskrivning. flag.Parse() tolkar argumenten i os.Args. Pekarna *project avrefereras för att få värden. Binären byggs med kommandot go build -o deploy deploy.go.

Gomobile: Go i inbyggda bibliotek för iOS och Android

Gomobile — Googles verktyg för att kompilera Go-kod till inbyggda mobilbibliotek. go bind -target=android genererar .aar för Android, go bind -target=ios genererar .xcframework för iOS. Detta gör det möjligt att skriva gemensam affärslogik i Go och anropa den från Kotlin och Swift.

Huvudscenarier för Gomobile: kryptografi (egna krypteringsscheman), nätverksarbete (eget protokoll över WebSocket), databehandling (komprimering, kodning, tolkning). UI skrivs inte i Go — dess uppgift är att ersätta C++ för plattformsoberoende inbyggda moduler.

package mobile

import "crypto/aes"

// EncryptData krypterar AES-256-GCM-data (exporteras till .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
}

Exporterade funktioner (med stor bokstav) omsluts av Gomobile i Java/Swift-gränssnitt. Från Kotlin ser anropet ut som Mobile.encryptData(key, plaintext). Gomobile konverterar automatiskt typer: []byte → byte[] (Java) / Data (Swift).

Go vs Java och Kotlin för backend: jämförelse

Go konkurrerar med Java och Kotlin inom serverutveckling. Huvudskillnader: Go kompileras till en inbyggd binär, kräver ingen JVM, förbrukar 2–3 gånger mindre minne och startar på millisekunder. Java vinner i ekosystemets mognad och antalet bibliotek.

Go väljs för mikrotjänster, API-gateways och verktyg. Java/Kotlin — för företagsapplikationer med rik affärslogik. Inom mobil utveckling är den optimala kombinationen: Go för backend, Kotlin/Swift för klienten.