Go para desarrollo móvil: backend, API y utilidades

¿Qué es Go?

Go es un lenguaje compilado de tipado estático con gestión automática de memoria mediante recolección de basura. Los objetivos principales de Go: compilación rápida, simplicidad de código y soporte integrado de concurrencia. Go se compila en un binario nativo sin máquina virtual — un solo archivo ejecutable lo contiene todo, incluidas las dependencias.

La biblioteca estándar de Go cubre servidor HTTP, marshaling JSON, análisis de flags de línea de comandos, cifrado y operaciones con bases de datos. No se necesita un framework externo para un servidor HTTP — net/http está integrado. Go Modules (desde v1.16) es el sistema de gestión de dependencias estándar. La versión actual es Go 1.23 (2025) con un paquete iter mejorado para iteradores.

Go fue diseñado para resolver los problemas de escalado que Google enfrentó: compilación lenta de C++, complejidad de Java, concurrencia ineficiente de Python. El resultado es un lenguaje que impulsa Docker, Kubernetes, Prometheus, Terraform y Hugo.

Sintaxis de Go

Go es minimalista: 25 palabras clave (frente a 84 en C++). No hay clases, herencia, genéricos (hasta v1.18), sobrecarga de operadores ni excepciones. Los errores se manejan explícitamente mediante devolución de error. Las estructuras e interfaces reemplazan la 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)
}

La estructura User con etiquetas JSON define la serialización. http.HandleFunc registra un manejador. json.NewEncoder(w).Encode(user) serializa la estructura a JSON directamente en la respuesta. El servidor HTTP integrado maneja las peticiones en gorutinas separadas automáticamente.

Goroutines y canales: modelo de concurrencia de Go

Goroutines son hilos de ejecución ligeros gestionados por el runtime de Go. A diferencia de los hilos del SO (1–8 MB de pila), una gorutina comienza con 4 KB de pila que crece dinámicamente. Se pueden ejecutar 100 000 gorutinas en un solo servidor. Iniciar una gorutina — go functionName().

Canales (channels) son colas tipadas para transferir datos entre gorutinas. Un canal se crea mediante make(chan Type). El operador <- envía datos, <-chan los recibe. Los canales pueden ser buferizados (con capacidad) o no buferizados (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)
	}
}

Tres peticiones se ejecutan concurrentemente mediante go fetchURL. El canal ch recoge los resultados. defer resp.Body.Close() garantiza el cierre de la respuesta al salir de la función. select {} no se usa ya que todas las gorutinas envían al canal — la gorutina principal lee exactamente len(urls) veces.

Go para backend de aplicaciones móviles

Go es uno de los mejores lenguajes para backend de aplicaciones móviles. HTTP/2 y HTTP/3 integrados, serialización rápida con protobuf/gRPC y bajo consumo de memoria hacen de Go una opción ideal para APIs que atienden a miles de clientes móviles.

Frameworks populares: Gin (hasta 10x más rápido que Express.js), Echo (minimalista, middleware JWT), Fiber (estilo Express), Chi (compatible con net/http). Gin es el más popular con más de 70k estrellas en GitHub. Para gRPC se usa 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 una ruta con un manejador. sql.Open abre una base de datos SQLite, db.Query ejecuta una consulta. c.JSON serializa el slice posts en un array JSON. La función anónima dentro de GET captura db del contexto externo. Gin maneja panics, registra peticiones y soporta middleware.

Microservicios y puertas de enlace API en Go

Go es el lenguaje principal para la arquitectura de microservicios. El bajo consumo de memoria por microservicio (15–30 MB) permite ejecutar docenas de servicios en un solo servidor. El arranque rápido (milisegundos) y el tamaño reducido del binario (10–20 MB) simplifican el despliegue en contenedores.

Una puerta de enlace API en Go agrega peticiones de una aplicación móvil a servicios internos. Una puerta de enlace Go maneja autenticación (JWT), limitación de velocidad, enrutamiento y almacenamiento en caché. Implementaciones populares: Kong (basado en OpenResty con plugins Go), Tyk (en Go), puertas de enlace personalizadas en Gin.

gRPC y protobuf

gRPC es un framework de llamada a procedimiento remoto de Google que utiliza Protocol Buffers para serialización y HTTP/2 para transporte. Go tiene el mejor soporte gRPC entre todos los lenguajes. Para backends móviles, gRPC proporciona un rendimiento 5–10 veces mayor 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 es un stub generado por protoc a partir del archivo .proto. La estructura server redefine el método GetUser. grpc.NewServer() crea un servidor con interceptores para registro, autenticación y métricas.

Go para utilidades CLI y herramientas de desarrollador

Go es el mejor lenguaje para utilidades CLI usadas en desarrollo móvil. Un solo binario estático (~10 MB) sin dependencias funciona en todas las plataformas: macOS, Linux, Windows. La compilación toma segundos. Las utilidades Go no requieren instalación de intérprete ni runtime.

Ejemplos de herramientas Go en el ecosistema móvil: Migrate (migraciones de BD), Kubectl (Kubernetes para backend móvil), Terraform (infraestructura), Prometheus (monitoreo). Los desarrolladores escriben utilidades Go para generar modelos a partir de archivos proto, validar configuraciones y desplegar microservicios.

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)
	}
	// aquí la lógica de despliegue
	fmt.Println("Deploy complete")
}

flag.String define un flag de línea de comandos de tipo string con nombre, valor predeterminado y descripción. flag.Parse() analiza los argumentos os.Args. Los punteros *project se desreferencian para obtener los valores. El binario se compila con go build -o deploy deploy.go.

Gomobile: Go en bibliotecas nativas para iOS y Android

Gomobile es una herramienta de Google para compilar código Go en bibliotecas móviles nativas. go bind -target=android genera .aar para Android, go bind -target=ios genera .xcframework para iOS. Esto permite escribir lógica de negocio común en Go y llamarla desde Kotlin y Swift.

Principales casos de uso de Gomobile: criptografía (esquemas de cifrado personalizados), redes (protocolo WebSocket propio), procesamiento de datos (compresión, codificación, análisis). La interfaz de usuario no se escribe en Go — su propósito es reemplazar C++ para módulos nativos multiplataforma.

package mobile

import "crypto/aes"

// EncryptData cifra datos con AES-256-GCM (exportado a .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
}

Las funciones exportadas (mayúsculas) son envueltas por Gomobile en interfaces Java/Swift. Desde Kotlin, la llamada se ve como Mobile.encryptData(key, plaintext). Gomobile convierte tipos automáticamente: []byte → byte[] (Java) / Data (Swift).

Go vs Java y Kotlin para backend: comparación

Go compite con Java y Kotlin en el desarrollo de servidores. Diferencias clave: Go se compila en un binario nativo, no requiere JVM, consume 2–3 veces menos memoria y arranca en milisegundos. Java gana en madurez del ecosistema y cantidad de bibliotecas.

Go se elige para microservicios, puertas de enlace API y herramientas. Java/Kotlin — para aplicaciones empresariales con lógica de negocio compleja. En desarrollo móvil, la combinación óptima es: Go para backend, Kotlin/Swift para el cliente.