Mobil geliştirme için Go: sunucu tarafı, API ve yardımcı programlar

Go nedir?

Go, çöp toplama yoluyla otomatik bellek yönetimine sahip statik olarak türlenmiş derlenmiş bir dildir. Go'nun ana hedefleri: hızlı derleme, kod basitliği ve yerleşik eşzamanlılık desteği. Go, sanal makine olmadan yerel ikili dosyaya derlenir — tek bir yürütülebilir dosya, bağımlılıklar dahil her şeyi içerir.

Go standart kitaplığı HTTP sunucusu, JSON marshaling, komut satırı bayrağı ayrıştırma, şifreleme ve veritabanı işlemlerini kapsar. Bir HTTP sunucusu için harici bir framework gerekmez — net/http yerleşiktir. Go Modules (v1.16'dan itibaren) standart bağımlılık yönetim sistemidir. Mevcut sürüm, yineleyiciler için geliştirilmiş iter paketiyle Go 1.23'tür (2025).

Go, Google'ın karşılaştığı ölçekleme sorunlarını çözmek için tasarlandı: yavaş C++ derlemesi, Java karmaşıklığı, verimsiz Python eşzamanlılığı. Sonuç, Docker, Kubernetes, Prometheus, Terraform ve Hugo'yu çalıştıran bir dildir.

Go sözdizimi

Go minimalisttir: 25 anahtar kelime (C++'ta 84'e kıyasla). Sınıf, kalıtım, jenerikler (v1.18'e kadar), operatör aşırı yüklemesi veya istisna yoktur. Hatalar, err dönüşü yoluyla açıkça işlenir. Yapılar ve arayüzler OOP'nin yerini alır.

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

JSON etiketlerine sahip User yapısı serileştirmeyi tanımlar. http.HandleFunc bir işleyici kaydeder. json.NewEncoder(w).Encode(user), yapıyı doğrudan yanıta JSON olarak serileştirir. Yerleşik HTTP sunucusu, istekleri otomatik olarak ayrı goroutine'lerde işler.

Goroutines ve kanallar: Go eşzamanlılık modeli

Goroutines, Go çalışma zamanı tarafından yönetilen hafif yürütme iş parçacıklarıdır. İşletim sistemi iş parçacıklarının (1–8 MB yığın) aksine, bir goroutine dinamik olarak büyüyen 4 KB yığınla başlar. Tek bir sunucuda 100.000 goroutine çalıştırılabilir. Goroutine başlatma — go functionName().

Kanallar (channels), goroutine'ler arasında veri aktarmak için türlenmiş kuyruklardır. Bir kanal make(chan Type) ile oluşturulur. <- operatörü veri gönderir, <-chan alır. Kanallar tamponlu (kapasiteli) veya tamponsuz (senkron) olabilir.

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

Üç istek, go fetchURL aracılığıyla eşzamanlı olarak yürütülür. ch kanalı sonuçları toplar. defer resp.Body.Close(), işlevden dönerken yanıtın kapanmasını garanti eder. select {} kullanılmaz çünkü tüm goroutine'ler kanala gönderir — ana goroutine tam olarak len(urls) kez okur.

Mobil uygulama backend'i için Go

Go, mobil uygulama backend'i için en iyi dillerden biridir. Yerleşik HTTP/2 ve HTTP/3, hızlı protobuf/gRPC serileştirme ve düşük bellek kullanımı, Go'yu binlerce mobil istemciye hizmet veren API'ler için ideal kılar.

Popüler framework'ler: Gin (Express.js'den 10 kata kadar daha hızlı), Echo (minimalist, JWT middleware), Fiber (Express benzeri), Chi (net/http uyumlu). Gin en popüler olanıdır ve GitHub'da 70k+ yıldıza sahiptir. gRPC için google.golang.org/grpc kullanılır.

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, bir işleyiciyle bir rota kaydeder. sql.Open bir SQLite veritabanı açar, db.Query bir sorgu yürütür. c.JSON, posts dilimini bir JSON dizisine serileştirir. GET içindeki anonim işlev, dış bağlamdan db'yi yakalar. Gin, panikleri işler, istekleri günlüğe kaydeder ve middleware'i destekler.

Go ile mikro servisler ve API ağ geçitleri

Go, mikro servis mimarisi için birincil dildir. Mikro servis başına düşük bellek tüketimi (15–30 MB), tek bir sunucuda düzinelerce hizmetin çalıştırılmasına olanak tanır. Hızlı başlatma (milisaniyeler) ve küçük ikili dosya boyutu (10–20 MB), konteyner dağıtımını basitleştirir.

Go'da bir API ağ geçidi, mobil uygulamadan iç hizmetlere gelen istekleri toplar. Bir Go ağ geçidi, kimlik doğrulama (JWT), hız sınırlama, yönlendirme ve önbelleğe almayı işler. Popüler uygulamalar: Kong (Go eklentileriyle OpenResty tabanlı), Tyk (Go ile), Gin üzerinde özel ağ geçitleri.

gRPC ve protobuf

gRPC, serileştirme için Protocol Buffers ve taşıma için HTTP/2 kullanan Google'ın uzak prosedür çağrısı framework'üdür. Go, tüm diller arasında en iyi gRPC desteğine sahiptir. Mobil backend'ler için gRPC, REST/JSON'dan 5–10 kat daha yüksek verim sağlar.

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, .proto dosyasından protoc tarafından oluşturulan bir saplamadır. server yapısı, GetUser yöntemini geçersiz kılar. grpc.NewServer(), günlük kaydı, kimlik doğrulama ve metrikler için interceptors ile bir sunucu oluşturur.

CLI yardımcı programları ve geliştirici araçları için Go

Go, mobil geliştirmede kullanılan CLI yardımcı programları için en iyi dildir. Bağımlılığı olmayan tek bir statik ikili dosya (~10 MB) tüm platformlarda çalışır: macOS, Linux, Windows. Derleme saniyeler sürer. Go yardımcı programları, yorumlayıcı veya çalışma zamanı kurulumu gerektirmez.

Mobil ekosistemdeki Go araçlarına örnekler: Migrate (DB migrasyonları), Kubectl (mobil backend için Kubernetes), Terraform (altyapı), Prometheus (izleme). Geliştiriciler, proto dosyalarından model oluşturma, yapılandırmaları doğrulama ve mikro servisleri dağıtmak için Go yardımcı programları yazar.

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

	if *verbose {
		fmt.Printf("Deploying project %s version %s\n", *project, *version)
	}
	// dağıtım mantığı burada
	fmt.Println("Deploy complete")
}

flag.String, ad, varsayılan değer ve açıklama ile bir dize komut satırı bayrağı tanımlar. flag.Parse(), os.Args argümanlarını ayrıştırır. *project işaretçileri, değerleri almak için referansları kaldırılır. İkili dosya, go build -o deploy deploy.go komutuyla oluşturulur.

Gomobile: iOS ve Android için yerel kitaplıklarda Go

Gomobile, Go kodunu yerel mobil kitaplıklara derlemek için bir Google aracıdır. go bind -target=android Android için .aar oluşturur, go bind -target=ios iOS için .xcframework oluşturur. Bu, ortak iş mantığını Go'da yazmayı ve Kotlin ile Swift'ten çağırmayı sağlar.

Gomobile'ın ana kullanım durumları: kriptografi (özel şifreleme şemaları), ağ oluşturma (özel WebSocket protokolü), veri işleme (sıkıştırma, kodlama, ayrıştırma). Kullanıcı arayüzü Go'da yazılmaz — amacı, çapraz platform yerel modülleri için C++'ın yerini almaktır.

package mobile

import "crypto/aes"

// EncryptData, AES-256-GCM ile verileri şifreler (.aar'a aktarılır)
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
}

Dışa aktarılan işlevler (büyük harfli) Gomobile tarafından Java/Swift arayüzlerine sarılır. Kotlin'den çağrı Mobile.encryptData(key, plaintext) gibi görünür. Gomobile türleri otomatik olarak dönüştürür: []byte → byte[] (Java) / Data (Swift).

Backend için Go vs Java ve Kotlin: karşılaştırma

Go, sunucu geliştirmede Java ve Kotlin ile rekabet eder. Temel farklar: Go yerel ikili dosyaya derlenir, JVM gerektirmez, 2–3 kat daha az bellek tüketir ve milisaniyeler içinde başlar. Java, ekosistem olgunluğu ve kitaplık sayısında öndedir.

Go, mikro servisler, API ağ geçitleri ve araçlar için seçilir. Java/Kotlin — zengin iş mantığına sahip kurumsal uygulamalar için. Mobil geliştirmede en uygun kombinasyon: backend için Go, istemci için Kotlin/Swift.