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. Структуре и интерфејси замењују 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("Сервер на :8080")
	http.ListenAndServe(":8080", nil)
}

Структура User са JSON ознакама дефинише серијализацију. http.HandleFunc региструје руковаоца. json.NewEncoder(w).Encode(user) серијализује структуру директно у JSON у одговору. Уграђени HTTP сервер обрађује захтеве аутоматски у одвојеним горутинама.

Горутине и канали: модел конкурентности Go-а

Goroutines — лагани извршни токови којима управља Go рантајм. За разлику од OS нити (1–8 MB стек), горутина почиње са 4 KB стека који динамички расте. Може се покренути 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("Грешка: %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 серијализује slice posts у JSON низ. Анонимна функција унутар GET-а хвата db из спољног контекста. Gin обрађује panic, логује захтеве и подржава middleware.

Микросервиси и API-пролази у Go-у

Go — главни језик за микросервисну архитектуру. Ниска потрошња меморије по микросервису (15–30 MB) омогућава покретање десетина сервиса на једном серверу. Брз старт (милисекунде) и мала величина бинарног фајла (10–20 MB) поједностављују примену у контејнерима.

API пролаз у Go-у агрегира захтеве од мобилне апликације ка унутрашњим сервисима. Golang пролаз обрађује аутентификацију (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 MB) без зависности ради на свим платформама: 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("Употреба: deploy --project=path [--version=x.x.x]")
		os.Exit(1)
	}

	if *verbose {
		fmt.Printf("Примена пројекта %s верзија %s
", *project, *version)
	}
	// овде логика примене
	fmt.Println("Примена завршена")
}

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++ за вишeплатформске изворне модуле.

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 за клијента.