Go para desenvolvimento mobile: backend, API e utilitários

O que é Go?

Go é uma linguagem compilada de tipagem estática com gerenciamento automático de memória via coleta de lixo. Os principais objetivos do Go: compilação rápida, simplicidade de código e suporte integrado a concorrência. Go compila em um binário nativo sem máquina virtual — um único arquivo executável contém tudo, incluindo dependências.

A biblioteca padrão do Go cobre servidor HTTP, marshaling JSON, análise de flags de linha de comando, criptografia e operações de banco de dados. Nenhum framework externo é necessário para um servidor HTTP — net/http é integrado. Go Modules (desde v1.16) é o sistema de gerenciamento de dependências padrão. A versão atual é Go 1.23 (2025) com um pacote iter melhorado para iteradores.

Go foi projetado para resolver os problemas de escalabilidade que o Google enfrentou: compilação lenta de C++, complexidade do Java, concorrência ineficiente do Python. O resultado é uma linguagem que alimenta Docker, Kubernetes, Prometheus, Terraform e Hugo.

Sintaxe do Go

Go é minimalista: 25 palavras-chave (comparado a 84 em C++). Não há classes, herança, genéricos (até v1.18), sobrecarga de operadores ou exceções. Erros são tratados explicitamente via retorno de err. Structs e interfaces substituem POO.

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

A struct User com tags JSON define a serialização. http.HandleFunc registra um manipulador. json.NewEncoder(w).Encode(user) serializa a struct para JSON diretamente na resposta. O servidor HTTP integrado lida com requisições em goroutines separadas automaticamente.

Goroutines e canais: modelo de concorrência do Go

Goroutines são threads de execução leves gerenciadas pelo runtime do Go. Ao contrário de threads do SO (1–8 MB de pilha), uma goroutine começa com 4 KB de pilha que cresce dinamicamente. É possível executar 100.000 goroutines em um único servidor. Iniciar uma goroutine — go functionName().

Canais (channels) são filas tipadas para transferir dados entre goroutines. Um canal é criado via make(chan Type). O operador <- envia dados, <-chan recebe. Canais podem ser bufferizados (com capacidade) ou não bufferizados (síncronos).

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

Três requisições executam concorrentemente via go fetchURL. O canal ch coleta resultados. defer resp.Body.Close() garante o fechamento da resposta ao retornar da função. select {} não é usado já que todas as goroutines enviam para o canal — a goroutine principal lê exatamente len(urls) vezes.

Go para backend de aplicativos mobile

Go é uma das melhores linguagens para backend de aplicativos mobile. HTTP/2 e HTTP/3 integrados, serialização rápida com protobuf/gRPC e baixo consumo de memória tornam Go ideal para APIs que atendem milhares de clientes móveis.

Frameworks populares: Gin (até 10x mais rápido que Express.js), Echo (minimalista, middleware JWT), Fiber (estilo Express), Chi (compatível com net/http). Gin é o mais popular com 70k+ estrelas no GitHub. Para gRPC, usa-se 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 registra uma rota com um manipulador. sql.Open abre um banco SQLite, db.Query executa uma consulta. c.JSON serializa o slice posts em um array JSON. A função anônima dentro de GET captura db do contexto externo. Gin lida com panics, registra requisições e suporta middleware.

Microsserviços e gateways de API em Go

Go é a linguagem principal para arquitetura de microsserviços. O baixo consumo de memória por microsserviço (15–30 MB) permite executar dezenas de serviços em um único servidor. Inicialização rápida (milissegundos) e tamanho reduzido do binário (10–20 MB) simplificam a implantação em contêineres.

Um gateway de API em Go agrega requisições de um aplicativo mobile para serviços internos. Um gateway Go lida com autenticação (JWT), limitação de taxa, roteamento e cache. Implementações populares: Kong (baseado em OpenResty com plugins Go), Tyk (em Go), gateways personalizados em Gin.

gRPC e protobuf

gRPC é um framework de chamada de procedimento remoto do Google que usa Protocol Buffers para serialização e HTTP/2 para transporte. Go tem o melhor suporte gRPC entre todas as linguagens. Para backends mobile, gRPC fornece 5–10x mais throughput que 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 é um stub gerado por protoc do arquivo .proto. A struct server sobrescreve o método GetUser. grpc.NewServer() cria um servidor com interceptores para logging, autenticação e métricas.

Go para utilitários CLI e ferramentas de desenvolvedor

Go é a melhor linguagem para utilitários CLI usados no desenvolvimento mobile. Um único binário estático (~10 MB) sem dependências funciona em todas as plataformas: macOS, Linux, Windows. A compilação leva segundos. Utilitários Go não requerem instalação de interpretador ou runtime.

Exemplos de ferramentas Go no ecossistema mobile: Migrate (migrações de BD), Kubectl (Kubernetes para backend mobile), Terraform (infraestrutura), Prometheus(monitoramento). Desenvolvedores escrevem utilitários Go para gerar modelos de arquivos proto, validar configurações e implantar microsserviços.

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)
	}
	// aqui a lógica de implantação
	fmt.Println("Deploy complete")
}

flag.String define uma flag de linha de comando do tipo string com nome, valor padrão e descrição. flag.Parse() analisa os argumentos os.Args. Ponteiros *project são desreferenciados para obter valores. O binário é compilado com go build -o deploy deploy.go.

Gomobile: Go em bibliotecas nativas para iOS e Android

Gomobile é uma ferramenta do Google para compilar código Go em bibliotecas móveis nativas. go bind -target=android gera .aar para Android, go bind -target=ios gera .xcframework para iOS. Isso permite escrever lógica de negócios comum em Go e chamá-la de Kotlin e Swift.

Principais casos de uso do Gomobile: criptografia (esquemas de criptografia personalizados), redes (protocolo WebSocket próprio), processamento de dados (compressão, codificação, análise). A interface do usuário não é escrita em Go — seu propósito é substituir C++ para módulos nativos multiplataforma.

package mobile

import "crypto/aes"

// EncryptData criptografa dados com AES-256-GCM (exportado para .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
}

Funções exportadas (maiúsculas) são encapsuladas pelo Gomobile em interfaces Java/Swift. Do Kotlin, a chamada parece Mobile.encryptData(key, plaintext). Gomobile converte tipos automaticamente: []byte → byte[] (Java) / Data (Swift).

Go vs Java e Kotlin para backend: comparação

Go compete com Java e Kotlin no desenvolvimento de servidores. Principais diferenças: Go compila em um binário nativo, não requer JVM, consome 2–3x menos memória e inicia em milissegundos. Java ganha em maturidade do ecossistema e quantidade de bibliotecas.

Go é escolhido para microsserviços, gateways de API e ferramentas. Java/Kotlin — para aplicações empresariais com lógica de negócios rica. No desenvolvimento mobile, a combinação ideal é: Go para backend, Kotlin/Swift para o cliente.