Mobil ishlanma uchun Go: server qismi, API va utilitalar

Go nima?

Go — axlat yig'uvchi orqali avtomatik xotira boshqaruvi bilan statik tipli kompilyatsiya qilinadigan til. Go-ning asosiy maqsadlari: tezkor kompilyatsiya, kod soddaligi va o'rnatilgan parallellik qo'llab-quvvatlashi. Go virtual mashinasiz mahalliy binar faylga kompilyatsiya qilinadi — bitta bajariladigan fayl hamma narsani, shu jumladan bog'liqliklarni o'z ichiga oladi.

Go-ning standart kutubxonasi HTTP server, JSON marshaling, buyruq satri bayroqlarini tahlil qilish, shifrlash va ma'lumotlar bazalari bilan ishlashni o'z ichiga oladi. HTTP server uchun tashqi freymvork kerak emas — net/http o'rnatilgan. Go Modules (1.16 versiyasidan) — bog'liqliklarni boshqarishning standart tizimi. Joriy versiya — Go 1.23 (2025) yaxshilangan iter paketi bilan.

Go Google duch kelgan masshtablash muammolarini hal qilish uchun ishlab chiqilgan: C++ ning sekin kompilyatsiyasi, Java ning murakkabligi, Python ning samarasiz parallelligi. Natija — Docker, Kubernetes, Prometheus, Terraform va Hugo yozilgan til.

Go sintaksisi

Go minimalistik: 25 kalit so'z (taqqoslash uchun C++ da 84). Sinflar, meros, generiklar (1.18 versiyasigacha), operatorlarni yuklash va istisnolar yo'q. Xatolar err qaytarish orqali aniq boshqariladi. Strukturalar va interfeyslar OOP ni almashtiradi.

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

JSON teglari bilan User strukturasi serializatsiyani belgilaydi. http.HandleFunc ishlov beruvchini ro'yxatdan o'tkazadi. json.NewEncoder(w).Encode(user) strukturani to'g'ridan-to'g'ri javobda JSON ga serializatsiya qiladi. O'rnatilgan HTTP server so'rovlarni avtomatik ravishda alohida gorutinlarda qayta ishlaydi.

Goroutines va kanallar: Go parallellik modeli

Goroutines — Go vaqtida boshqariladigan yengil bajarish oqimlari. OT oqimlaridan (1–8 MB stek) farqli o'laroq, gorutin 4 KB stek bilan boshlanadi va dinamik ravishda o'sadi. Bitta serverda 100 000 gorutin ishga tushirish mumkin. Gorutinni ishga tushirish — go functionName().

Kanallar (channels) — gorutinlar o'rtasida ma'lumot uzatish uchun tipli navbatlar. Kanal make(chan Type) orqali yaratiladi. <- operatori ma'lumot yuboradi, <-chan qabul qiladi. Kanallar buferlangan (sig'imli) va buferlanmagan (sinxron) bo'lishi mumkin.

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

Uchta so'rov go fetchURL orqali parallel bajariladi. ch kanali natijalarni to'playdi. defer resp.Body.Close() funksiyadan qaytganda javobning yopilishini kafolatlaydi. select {} ishlatilmaydi, chunki barcha gorutinlar kanalga yuboradi — asosiy oqim aniq len(urls) marta o'qiydi.

Mobil ilovalarning server qismi uchun Go

Go — mobil ilovalar backend uchun eng yaxshi tillardan biri. O'rnatilgan HTTP/2 va HTTP/3, tezkor protobuf/gRPC serializatsiyasi va past xotira iste'moli Go ni minglab mobil mijozlarga xizmat ko'rsatadigan API lar uchun ideal qiladi.

Mashhur freymvorklar: Gin (Express.js dan 10x tezroq), Echo (minimalistik, JWT middleware), Fiber (Express uslubida), Chi (net/http bilan mos). Gin eng mashhur, GitHub da 70k+ yulduzi bor. gRPC uchun google.golang.org/grpc ishlatiladi.

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 ishlov beruvchi bilan marshrutni ro'yxatdan o'tkazadi. sql.Open SQLite ma'lumotlar bazasini ochadi, db.Query so'rovni bajaradi. c.JSON posts slice ni JSON massiviga serializatsiya qiladi. GET ichidagi anonim funksiya tashqi kontekstdan db ni oladi. Gin panic ni boshqaradi, so'rovlarni qayd qiladi va middleware ni qo'llab-quvvatlaydi.

Go-da mikros xizmatlar va API shlyuzlari

Go — mikros xizmat arxitekturasi uchun asosiy til. Bir mikros xizmat uchun past xotira iste'moli (15–30 MB) bitta serverda o'nlab xizmatlarni ishga tushirishga imkon beradi. Tez ishga tushish (millisoniyalar) va kichik binar fayl hajmi (10–20 MB) konteynerlarda joylashtirishni osonlashtiradi.

Go da API shlyuzi mobil ilovadan ichki xizmatlarga so'rovlarni yig'adi. Golang shlyuzi autentifikatsiya (JWT), rate limiting, marshrutlash va keshlashni boshqaradi. Mashhur tatbiqlar: Kong (OpenResty va Go plaginlari asosida), Tyk (Go da), Gin da o'z shlyuzlari.

gRPC va protobuf

gRPC — Google dan masofaviy protsedura chaqiruvi freymvorki, serializatsiya uchun Protocol Buffers va transport uchun HTTP/2 dan foydalanadi. Go barcha tillar orasida eng yaxshi gRPC qo'llab-quvvatlashiga ega. Mobil backend uchun gRPC REST/JSON dan 5–10 baravar yuqori o'tkazuvchanlikni ta'minlaydi.

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 faylidan protoc tomonidan yaratilgan tayanch. server strukturasi GetUser metodini bekor qiladi. grpc.NewServer() kirish, autentifikatsiya va metrikalar uchun interceptors bilan server yaratadi.

CLI utilitalari va ishlab chiquvchi vositalari uchun Go

Go — mobil ishlanmada ishlatiladigan CLI utilitalari uchun eng yaxshi til. Bog'liqliklarsiz bitta statik binar fayl (~10 MB) barcha platformalarda ishlaydi: macOS, Linux, Windows. Kompilyatsiya soniyalar davom etadi. Go utilitalari interpretator yoki vaqtni o'rnatishni talab qilmaydi.

Mobil ekotizimda Go vositalariga misollar: Migrate (MB migratsiyalari), Kubectl (mobil backend uchun Kubernetes), Terraform (infratuzilma), Prometheus(monitoring). Ishlab chiquvchilar proto fayllardan modellar yaratish, konfiguratsiyalarni tekshirish va mikros xizmatlarni joylashtirish uchun Go utilitalarini yozadi.

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

	if *verbose {
		fmt.Printf("%s versiya %s loyihasi joylashtirilmoqda
", *project, *version)
	}
	// bu yerda joylashtirish mantig'i
	fmt.Println("Joylashtirish tugallandi")
}

flag.String nom, standart qiymat va tavsif bilan buyruq satri satr bayrog'ini belgilaydi. flag.Parse() os.Args argumentlarini tahlil qiladi. *project ko'rsatkichlari qiymatlarni olish uchun dereferensiya qilinadi. Binar fayl go build -o deploy deploy.go buyrug'i bilan yig'iladi.

Gomobile: iOS va Android uchun mahalliy kutubxonalarda Go

Gomobile — Go kodini mahalliy mobil kutubxonalarga kompilyatsiya qilish uchun Google vositasi. go bind -target=android Android uchun .aar, go bind -target=ios iOS uchun .xcframework yaratadi. Bu umumiy biznes mantiqini Go da yozish va uni Kotlin va Swift dan chaqirish imkonini beradi.

Gomobile ning asosiy stsenariylari: kriptografiya (o'z shifrlash sxemalari), tarmoq bilan ishlash (WebSocket orqali o'z protokol), ma'lumotlarni qayta ishlash (siqish, kodlash, tahlil qilish). UI Go da yozilmaydi — uning vazifasi ko'p platformali mahalliy modullar uchun C++ ni almashtirishdir.

package mobile

import "crypto/aes"

// EncryptData AES-256-GCM ma'lumotlarini shifrlaydi (.aar ga eksport qilinadi)
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
}

Eksport qilinadigan funksiyalarni (katta harf bilan) Gomobile Java/Swift interfeysiga o'raydi. Kotlin dan chaqiruv Mobile.encryptData(key, plaintext) kabi ko'rinadi. Gomobile turlarni avtomatik ravishda o'zgartiradi: []byte → byte[] (Java) / Data (Swift).

Backend uchun Go vs Java va Kotlin: taqqoslash

Go server ishlanmasida Java va Kotlin bilan raqobatlashadi. Asosiy farqlar: Go mahalliy binar faylga kompilyatsiya qilinadi, JVM talab qilmaydi, 2–3 baravar kam xotira sarflaydi va millisoniyalarda ishga tushadi. Java ekotizimning etukligida va kutubxonalar sonida g'alaba qozonadi.

Go mikros xizmatlar, API shlyuzlari va vositalar uchun tanlanadi. Java/Kotlin — boy biznes mantiqiga ega enterprise ilovalar uchun. Mobil ishlanmada optimal to'plam: backend uchun Go, mijoz uchun Kotlin/Swift.