Mobil inkişaf üçün Go: server hissəsi, API və alətlər

Go nədir?

Go — zibil yığan vasitəsilə avtomatik yaddaş idarəetməsi olan statik tipli kompilyasiya olunan dildir. Go-nun əsas məqsədləri: sürətli kompilyasiya, kod sadəliyi və daxili paralellik dəstəyi. Go virtual maşın olmadan yerli binar fayla kompilyasiya olunur — bir icra edilə bilən fayl hər şeyi, o cümlədən asılılıqları ehtiva edir.

Go-nun standart kitabxanası HTTP server, JSON marsallinqi, komanda sətri bayraqlarının pars edilməsi, şifrələmə və verilənlər bazaları ilə işi əhatə edir. HTTP server üçün xarici freymvork lazım deyil — net/http daxilidir. Go Modules (versiya 1.16-dan) — asılılıqların idarə edilməsi üçün standart sistem. Cari versiya — Go 1.23 (2025) təkmilləşdirilmiş iter paketi ilə.

Go Google-ın qarşılaşdığı miqyaslama problemlərini həll etmək üçün hazırlanmışdır: C++-ın yavaş kompilyasiyası, Java-nın mürəkkəbliyi, Python-un səmərəsiz paralelliyi. Nəticə — Docker, Kubernetes, Prometheus, Terraform və Hugo-nun yazıldığı dil.

Go sintaksisi

Go minimalistikdir: 25 açar söz (müqayisə üçün C++-da 84). Siniflər, miras, generiklər (1.18 versiyasına qədər), operatorların yüklənməsi və istisnalar yoxdur. Səhvlər err qaytarmaqla açıq şəkildə idarə olunur. Strukturlar və interfeyslər OOP-ni əvəz edir.

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

JSON teqləri olan User strukturu serializasiyanı təyin edir. http.HandleFunc idarəedici qeydiyyatdan keçirir. json.NewEncoder(w).Encode(user) strukturu birbaşa cavabda JSON-a serializasiya edir. Daxili HTTP server sorğuları avtomatik olaraq ayrı qorutinlərdə idarə edir.

Goroutines və kanallar: Go paralellik modeli

Goroutines — Go runtimı tərəfindən idarə olunan yüngül icra axınları. ƏS axınlarından (1–8 MB yığın) fərqli olaraq, qorutin 4 KB yığınla başlayır və dinamik olaraq böyüyür. Bir serverdə 100 000 qorutin işə salmaq olar. Qorutini işə salmaq — go functionName().

Kanallar (channels) — qorutinlər arasında məlumat ötürmək üçün tipli növbələr. Kanal make(chan Type) ilə yaradılır. <- operatoru məlumat göndərir, <-chan qəbul edir. Kanallar buferlənmiş (tutumlu) və buferlənməmiş (sinxron) ola bilər.

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("Xəta: %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)
	}
}

Üç sorğu go fetchURL vasitəsilə paralel icra olunur. ch kanalı nəticələri toplayır. defer resp.Body.Close() funksiyadan qayıdarkən cavabın bağlanmasını təmin edir. select {} istifadə olunmur, çünki bütün qorutinlər kanala göndərir — əsas axın dəqiq len(urls) dəfə oxuyur.

Mobil tətbiqlərin server hissəsi üçün Go

Go — mobil tətbiqlərin backend-i üçün ən yaxşı dillərdən biridir. Daxili HTTP/2 və HTTP/3, sürətli protobuf/gRPC serializasiyası və aşağı yaddaş istehlakı Go-nu minlərlə mobil müştəriyə xidmət edən API-lər üçün ideal edir.

Məşhur freymvorklar: Gin (Express.js-dən 10x sürətli), Echo (minimalistik, JWT middleware), Fiber (Express üslubunda), Chi (net/http ilə uyğun). Gin ən populyardır, GitHub-da 70k+ ulduzu var. gRPC üçün google.golang.org/grpc istifadə olunur.

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 idarəedici ilə marşrut qeydiyyatdan keçirir. sql.Open SQLite verilənlər bazasını açır, db.Query sorğunu icra edir. c.JSON posts slice-nı JSON massivinə serializasiya edir. GET daxilində anonim funksiya xarici kontekstdən db-ni tutur. Gin panic-i idarə edir, sorğuları qeydə alır və middleware-i dəstəkləyir.

Go-da mikroservislər və API şlüzləri

Go — mikroservis arxitekturası üçün əsas dildir. Bir mikroservis üçün aşağı yaddaş istehlakı (15–30 MB) bir serverdə onlarla xidmət işə salmağa imkan verir. Sürətli başlanğıc (millisaniyələr) və kiçik binar fayl ölçüsü (10–20 MB) konteynerlərdə yerləşdirməni asanlaşdırır.

Go-da API şlüzü mobil tətbiqdən daxili xidmətlərə sorğuları toplayır. Golang şlüzü autentifikasiya (JWT), rate limiting, marşrutlaşdırma və keşləməni idarə edir. Məşhur tətbiqlər: Kong (OpenResty və Go plaginləri əsasında), Tyk (Go-da), Gin-də öz şlüzləri.

gRPC və protobuf

gRPC — Google-dan uzaqdan prosedur çağırışı freymvorku, serializasiya üçün Protocol Buffers və nəqliyyat üçün HTTP/2 istifadə edir. Go bütün dillər arasında ən yaxşı gRPC dəstəyinə malikdir. Mobil backend üçün gRPC REST/JSON-dan 5–10 dəfə yüksək ötürmə qabiliyyəti təmin edir.

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 faylından protoc tərəfindən yaradılan dayaq. server strukturu GetUser metodunu ləğv edir. grpc.NewServer() giriş, autentifikasiya və metrikalar üçün interceptorlarla server yaradır.

CLI alətləri və tərtibatçı vasitələri üçün Go

Go — mobil inkişafda istifadə olunan CLI alətləri üçün ən yaxşı dildir. Asılılıqları olmayan bir statik binar fayl (~10 MB) bütün platformalarda işləyir: macOS, Linux, Windows. Kompilyasiya saniyələr çəkir. Go alətləri interpretator və ya runtime quraşdırılması tələb etmir.

Mobil ekosistemdə Go alətlərinin nümunələri: Migrate (VB miqrasiyaları), Kubectl (mobil backend üçün Kubernetes), Terraform (infrastruktur), Prometheus (monitorinq). Tərtibatçılar proto-fayllardan modellər yaratmaq, konfiqurasiyaları yoxlamaq və mikroservisləri yerləşdirmək üçün Go alətləri yazır.

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

	if *verbose {
		fmt.Printf("%s versiya %s layihəsi yerləşdirilir
", *project, *version)
	}
	// burada yerləşdirmə məntiqi
	fmt.Println("Yerləşdirmə tamamlandı")
}

flag.String ad, standart dəyər və təsvirlə komanda sətri sətir bayrağını təyin edir. flag.Parse() os.Args arqumentlərini pars edir. *project göstəriciləri dəyərləri almaq üçün dereferensiya olunur. Binar fayl go build -o deploy deploy.go komandası ilə yığılır.

Gomobile: iOS və Android üçün yerli kitabxanalarda Go

Gomobile — Go kodunu yerli mobil kitabxanalara kompilyasiya etmək üçün Google alətidir. go bind -target=android Android üçün .aar, go bind -target=ios iOS üçün .xcframework yaradır. Bu, ümumi biznes məntiqini Go-da yazmağa və onu Kotlin və Swift-dən çağırmağa imkan verir.

Gomobile-in əsas ssenariləri: kriptoqrafiya (öz şifrələmə sxemləri), şəbəkə ilə iş (WebSocket üzərində öz protokol), məlumatların emalı (sıxlaşdırma, kodlaşdırma, pars etmə). UI Go-da yazılmır — onun vəzifəsi çarpaz platformalı yerli modullar üçün C++-ı əvəz etməkdir.

package mobile

import "crypto/aes"

// EncryptData AES-256-GCM məlumatlarını şifrələyir (.aar-a ixrac olunur)
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
}

İxrac olunan funksiyaları (böyük hərflə) Gomobile Java/Swift interfeysinə bükür. Kotlin-dən çağırış Mobile.encryptData(key, plaintext) kimi görünür. Gomobile tipləri avtomatik çevirir: []byte → byte[] (Java) / Data (Swift).

Backend üçün Go vs Java və Kotlin: müqayisə

Go server inkişafında Java və Kotlin ilə rəqabət aparır. Əsas fərqlər: Go yerli binar fayla kompilyasiya olunur, JVM tələb etmir, 2–3 dəfə az yaddaş sərf edir və millisaniyələrdə işə düşür. Java ekosistemin yetkinliyində və kitabxanaların sayında qalib gəlir.

Go mikroservislər, API şlüzləri və alətlər üçün seçilir. Java/Kotlin — zəngin biznes məntiqi olan enterprise tətbiqlər üçün. Mobil inkişafda optimal dəst: backend üçün Go, kliyent üçün Kotlin/Swift.