Go для мобільної розробки: серверна частина, API та утиліти

Що таке Go?

Go — статично типізована компільована мова з автоматичним керуванням пам'яттю через збирач сміття. Головні цілі Go: швидка компіляція, простота коду та вбудована підтримка конкурентності. Go компілюється в нативний бінарник без віртуальної машини — один виконуваний файл містить все, включаючи залежності.

Стандартна бібліотека Go покриває HTTP-сервер, JSON-маршалінг, парсинг флагів командного рядка, шифрування та роботу з базами даних. Для HTTP-сервера не потрібен зовнішній фреймворк — net/http вбудовано. Go Modules (з версії 1.16) — стандартна система керування залежностями. Актуальна версія — Go 1.23 (2025) з покращеним iter-пакетом для ітераторів.

Go розроблявся для вирішення проблем масштабування, з якими зіткнулася Google: повільна компіляція C++, складність Java, неефективна конкурентність Python. Результат — мова, на якій написані Docker, Kubernetes, Prometheus, Terraform та Hugo.

Синтаксис Go

Go мінімалістичний: 25 ключових слів (для порівняння в C++ — 84). Відсутні класи, наслідування, дженерики (до версії 1.18), перевантаження операторів та винятки. Помилки обробляються явно через повернення err. Структури та інтерфейси замінюють ООП.

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)
}

Структура User з JSON-тегами визначає серіалізацію. http.HandleFunc реєструє обробник. json.NewEncoder(w).Encode(user) серіалізує структуру в JSON безпосередньо у відповідь. Вбудований HTTP-сервер обробляє запити в окремих горутинах автоматично.

Goroutines та канали: модель конкурентності Go

Goroutines — легкі потоки виконання, керовані рантаймом Go. На відміну від потоків ОС (1–8 МБ стеку), горутина стартує з 4 КБ стеку, який динамічно зростає. Можна запустити 100 000 горутин на одному сервері. Запуск горутини — go functionName().

Канали (channels) — типізовані черги для передачі даних між горутинами. Канал створюється через make(chan Type). Оператор <- надсилає дані, <-chan приймає. Канали можуть бути буферизованими (з ємністю) та небуферизованими (синхронними).

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)
	}
}

Три запити виконуються паралельно через go fetchURL. Канал ch збирає результати. defer resp.Body.Close() гарантує закриття відповіді при поверненні з функції. select {} не використовується, оскільки всі горутини надсилають у канал — основний потік читає рівно len(urls) разів.

Go для серверної частини мобільних додатків

Go — одна з найкращих мов для бекенду мобільних додатків. Вбудовані HTTP/2 та HTTP/3, швидка серіалізація protobuf/gRPC та низьке споживання пам'яті роблять Go ідеальним для API, що обслуговують тисячі мобільних клієнтів.

Популярні фреймворки: Gin (до 10x швидше Express.js), Echo (мінімалістичний, JWT middleware), Fiber (у стилі Express), Chi (сумісний з net/http). Gin — найпопулярніший з 70k+ зірок на GitHub. Для gRPC використовується 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 реєструє роут з обробником. sql.Open відкриває SQLite-базу, db.Query виконує запит. c.JSON серіалізує слайс posts у JSON-масив. Анонімна функція всередині GET захоплює db із зовнішнього контексту. Gin обробляє паніку, логує запити та підтримує middleware.

Мікросервіси та API-шлюзи на Go

Go — основна мова для мікросервісної архітектури. Низьке споживання пам'яті на мікросервіс (15–30 МБ) дозволяє запускати десятки сервісів на одному сервері. Швидкий старт (мілісекунди) та малий розмір бінарника (10–20 МБ) спрощують деплой у контейнерах.

API Gateway на Go агрегує запити від мобільного додатку до внутрішніх сервісів. Go-шлюз обробляє аутентифікацію (JWT), rate limiting, маршрутизацію та кешування. Популярні реалізації: Kong (на базі OpenResty та Go-плагінів), Tyk (на Go), власні шлюзи на Gin.

gRPC та protobuf

gRPC — фреймворк віддаленого виклику процедур від Google, що використовує Protocol Buffers для серіалізації та HTTP/2 для транспорту. Go має найкращу підтримку gRPC серед усіх мов. Для мобільного бекенду gRPC забезпечує в 5–10 разів вищу пропускну здатність ніж 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 — заглушка, згенерована protoc з .proto файлу. Структура server перевизначає метод GetUser. grpc.NewServer() створює сервер з перехоплювачами для логування, аутентифікації та метрик.

Go для CLI-утиліт та інструментів розробника

Go — найкраща мова для CLI-утиліт, що використовуються в мобільній розробці. Один статичний бінарник (~10 МБ) без залежностей працює на всіх платформах: macOS, Linux, Windows. Компіляція триває секунди. Go-утиліти не вимагають встановлення інтерпретатора або рантайму.

Приклади Go-інструментів у мобільній екосистемі: Migrate (міграції БД), Kubectl (Kubernetes для мобільного бекенду), Terraform (інфраструктура), Prometheus (моніторинг). Розробники пишуть Go-утиліти для генерації моделей з proto-файлів, валідації конфігурацій та розгортання мікросервісів.

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)
	}
	// тут логіка деплою
	fmt.Println("Deploy complete")
}

flag.String визначає рядковий флаг командного рядка з іменем, значенням за замовчуванням та описом. flag.Parse() розбирає аргументи os.Args. Вказівники *project розіменовуються для отримання значень. Бінарник збирається командою go build -o deploy deploy.go.

Gomobile: Go в нативних бібліотеках для iOS та Android

Gomobile — інструмент Google для компіляції Go-коду в нативні мобільні бібліотеки. go bind -target=android генерує .aar для Android, go bind -target=ios — .xcframework для iOS. Це дозволяє писати спільну бізнес-логіку на Go та викликати її з Kotlin та Swift.

Основні сценарії Gomobile: криптографія (власні схеми шифрування), робота з мережею (власний протокол поверх WebSocket), обробка даних (стиснення, кодування, парсинг). UI на Go не пишуть — його задача замінити C++ для кроссплатформених нативних модулів.

package mobile

import "crypto/aes"

// EncryptData шифрує дані AES-256-GCM (експортується в .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
}

Експортовані функції (з великої літери) Gomobile обгортає в Java/Swift-інтерфейс. З Kotlin виклик виглядає як Mobile.encryptData(key, plaintext). Gomobile автоматично конвертує типи: []byte → byte[] (Java) / Data (Swift).

Go проти Java та Kotlin для бекенду: порівняння

Go конкурує з Java та Kotlin у серверній розробці. Ключові відмінності: Go компілюється в нативний бінарник, не потребує JVM, споживає в 2–3 рази менше пам'яті та запускається за мілісекунди. Java виграє в зрілості екосистеми та кількості бібліотек.

Go обирають для мікросервісів, API-шлюзів та інструментів. Java/Kotlin — для enterprise-додатків з багатою бізнес-логікою. У мобільній розробці оптимальна зв'язка: Go для бекенду, Kotlin/Swift для клієнта.