Go cho phát triển di động: phần máy chủ, API và tiện ích

Go là gì?

Go là ngôn ngữ biên dịch kiểu tĩnh với quản lý bộ nhớ tự động qua bộ thu gom rác. Mục tiêu chính của Go: biên dịch nhanh, mã đơn giản và hỗ trợ đồng thời tích hợp. Go biên dịch thành tệp nhị phân gốc không cần máy ảo — một tệp thực thi duy nhất chứa mọi thứ, bao gồm cả phụ thuộc.

Thư viện chuẩn của Go bao gồm máy chủ HTTP, tuần tự hóa JSON, phân tích cờ dòng lệnh, mã hóa và thao tác cơ sở dữ liệu. Không cần framework bên ngoài cho máy chủ HTTP — net/http được tích hợp sẵn. Go Modules (từ v1.16) là hệ thống quản lý phụ thuộc tiêu chuẩn. Phiên bản hiện tại là Go 1.23 (2025) với gói iter cải tiến cho iterator.

Go được thiết kế để giải quyết các vấn đề mở rộng mà Google gặp phải: biên dịch C++ chậm, độ phức tạp của Java, đồng thời Python kém hiệu quả. Kết quả là một ngôn ngữ vận hành Docker, Kubernetes, Prometheus, Terraform và Hugo.

Cú pháp Go

Go tối giản: 25 từ khóa (so với 84 trong C++). Không có lớp, kế thừa, generic (cho đến v1.18), nạp chồng toán tử hay ngoại lệ. Lỗi được xử lý rõ ràng qua trả về err. Cấu trúc và interface thay thế 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("Server on :8080")
	http.ListenAndServe(":8080", nil)
}

Cấu trúc User với thẻ JSON xác định tuần tự hóa. http.HandleFunc đăng ký một trình xử lý. json.NewEncoder(w).Encode(user) tuần tự hóa cấu trúc thành JSON trực tiếp vào phản hồi. Máy chủ HTTP tích hợp xử lý yêu cầu trong các goroutine riêng biệt một cách tự động.

Goroutines và kênh: mô hình đồng thời của Go

Goroutines là luồng thực thi nhẹ được quản lý bởi runtime Go. Không giống luồng OS (1–8 MB stack), goroutine bắt đầu với 4 KB stack và phát triển động. Có thể chạy 100.000 goroutine trên một máy chủ. Khởi động goroutine — go functionName().

Kênh (channels) là hàng đợi có kiểu để truyền dữ liệu giữa các goroutine. Kênh được tạo qua make(chan Type). Toán tử <- gửi dữ liệu, <-chan nhận. Kênh có thể có bộ đệm (có dung lượng) hoặc không có bộ đệm (đồng bộ).

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

Ba yêu cầu thực thi đồng thời qua go fetchURL. Kênh ch thu thập kết quả. defer resp.Body.Close() đảm bảo đóng phản hồi khi thoát khỏi hàm. select {} không được dùng vì tất cả goroutine đều gửi vào kênh — goroutine chính đọc đúng len(urls) lần.

Go cho backend ứng dụng di động

Go là một trong những ngôn ngữ tốt nhất cho backend ứng dụng di động. HTTP/2 và HTTP/3 tích hợp, tuần tự hóa nhanh protobuf/gRPC và bộ nhớ thấp khiến Go trở nên lý tưởng cho API phục vụ hàng nghìn khách hàng di động.

Framework phổ biến: Gin (nhanh hơn Express.js tới 10 lần), Echo (tối giản, middleware JWT), Fiber (kiểu Express), Chi (tương thích net/http). Gin phổ biến nhất với 70k+ sao trên GitHub. Cho gRPC, dùng 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 đăng ký route với trình xử lý. sql.Open mở cơ sở dữ liệu SQLite, db.Query thực thi truy vấn. c.JSON tuần tự hóa slice posts thành mảng JSON. Hàm ẩn danh bên trong GET capture db từ ngữ cảnh bên ngoài. Gin xử lý panic, ghi log yêu cầu và hỗ trợ middleware.

Microservice và cổng API bằng Go

Go là ngôn ngữ chính cho kiến trúc microservice. Tiêu thụ bộ nhớ thấp mỗi microservice (15–30 MB) cho phép chạy hàng chục dịch vụ trên một máy chủ. Khởi động nhanh (miligiây) và kích thước tệp nhị phân nhỏ (10–20 MB) đơn giản hóa việc triển khai trong container.

Cổng API bằng Go tổng hợp yêu cầu từ ứng dụng di động đến các dịch vụ nội bộ. Cổng Go xử lý xác thực (JWT), giới hạn tốc độ, định tuyến và bộ nhớ đệm. Triển khai phổ biến: Kong (dựa trên OpenResty với plugin Go), Tyk (bằng Go), cổng tùy chỉnh trên Gin.

gRPC và protobuf

gRPC là framework gọi thủ tục từ xa của Google sử dụng Protocol Buffers cho tuần tự hóa và HTTP/2 cho truyền tải. Go có hỗ trợ gRPC tốt nhất trong tất cả các ngôn ngữ. Cho backend di động, gRPC cung cấp thông lượng cao hơn 5–10 lần so với 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 là stub được protoc tạo từ tệp .proto. Cấu trúc server ghi đè phương thức GetUser. grpc.NewServer() tạo máy chủ với bộ chặn cho ghi log, xác thực và số liệu.

Go cho tiện ích CLI và công cụ phát triển

Go là ngôn ngữ tốt nhất cho tiện ích CLI dùng trong phát triển di động. Một tệp nhị phân tĩnh duy nhất (~10 MB) không phụ thuộc chạy trên mọi nền tảng: macOS, Linux, Windows. Biên dịch mất vài giây. Tiện ích Go không cần cài đặt trình thông dịch hay runtime.

Ví dụ công cụ Go trong hệ sinh thái di động: Migrate (di chuyển DB), Kubectl (Kubernetes cho backend di động), Terraform (hạ tầng), Prometheus (giám sát). Nhà phát triển viết tiện ích Go để tạo mô hình từ tệp proto, xác thực cấu hình và triển khai microservice.

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)
	}
	// logic triển khai ở đây
	fmt.Println("Deploy complete")
}

flag.String định nghĩa cờ dòng lệnh kiểu chuỗi với tên, giá trị mặc định và mô tả. flag.Parse() phân tích tham số os.Args. Con trỏ *project được giải tham chiếu để lấy giá trị. Tệp nhị phân được xây dựng bằng lệnh go build -o deploy deploy.go.

Gomobile: Go trong thư viện gốc cho iOS và Android

Gomobile là công cụ của Google để biên dịch mã Go thành thư viện di động gốc. go bind -target=android tạo .aar cho Android, go bind -target=ios tạo .xcframework cho iOS. Điều này cho phép viết logic nghiệp vụ chung bằng Go và gọi từ Kotlin và Swift.

Trường hợp sử dụng chính của Gomobile: mật mã (lược đồ mã hóa tùy chỉnh), mạng (giao thức WebSocket tùy chỉnh), xử lý dữ liệu (nén, mã hóa, phân tích). UI không được viết bằng Go — mục đích của nó là thay thế C++ cho các mô-đun gốc đa nền tảng.

package mobile

import "crypto/aes"

// EncryptData mã hóa dữ liệu bằng AES-256-GCM (xuất sang .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
}

Các hàm xuất khẩu (chữ hoa) được Gomobile bọc trong giao diện Java/Swift. Từ Kotlin, lời gọi trông như Mobile.encryptData(key, plaintext). Gomobile tự động chuyển đổi kiểu: []byte → byte[] (Java) / Data (Swift).

Go so với Java và Kotlin cho backend: so sánh

Go cạnh tranh với Java và Kotlin trong phát triển máy chủ. Khác biệt chính: Go biên dịch thành tệp nhị phân gốc, không cần JVM, tiêu thụ ít hơn 2–3 lần bộ nhớ và khởi động trong miligiây. Java thắng về độ trưởng thành của hệ sinh thái và số lượng thư viện.

Go được chọn cho microservice, cổng API và công cụ. Java/Kotlin — cho ứng dụng doanh nghiệp với logic nghiệp vụ phong phú. Trong phát triển di động, kết hợp tối ưu: Go cho backend, Kotlin/Swift cho client.