Go HTTP Frameworks & REST APIs

Overview

Go provides exceptional HTTP capabilities starting with the standard library's net/http package. Go 1.22+ introduced enhanced pattern routing in ServeMux, making stdlib viable for many applications. For more complex needs, frameworks like Chi, Gin, Echo, and Fiber offer additional features while maintaining Go's simplicity and performance.

Key Features:

• 🌐 net/http: Production-ready standard library with Go 1.22+ routing
• 🎯 Chi: Lightweight, stdlib-compatible router with middleware chains
• ⚡ Gin: High-performance framework with binding and validation
• 🛡️ Echo: Type-safe, enterprise framework with OpenAPI support
• 🚀 Fiber: Express.js-inspired framework with WebSocket support
• 🔧 Middleware: Composable request/response processing
• ✅ Validation: Struct tag-based request validation
• 🧪 Testing: httptest.Server for comprehensive integration tests

When to Use This Skill

Activate this skill when:

• Building RESTful APIs or web services
• Choosing appropriate HTTP framework for project requirements
• Implementing authentication or authorization middleware
• Designing REST endpoint patterns and validation
• Testing HTTP handlers and middleware chains
• Optimizing API performance and response times
• Migrating between HTTP frameworks

Framework Selection Guide

net/http (Standard Library) - Go 1.22+

Use When:

• Building simple to moderate complexity APIs
• Avoiding external dependencies is priority
• Need maximum compatibility and long-term stability
• Team prefers explicit over implicit patterns

Strengths:

• Zero dependencies, part of Go standard library
• Go 1.22+ pattern routing with path parameters
• Excellent performance and stability
• Extensive ecosystem compatibility
• No framework lock-in

Limitations:

• More verbose middleware composition
• Manual request validation
• No built-in binding or rendering

Example:

package main

import (
    "encoding/json"
    "net/http"
    "log"
)

// Go 1.22+ pattern routing
func main() {
    mux := http.NewServeMux()

    // Path parameters with {param} syntax
    mux.HandleFunc("GET /users/{id}", getUserHandler)
    mux.HandleFunc("POST /users", createUserHandler)
    mux.HandleFunc("GET /users", listUsersHandler)

    // Middleware wrapping
    handler := loggingMiddleware(mux)

    log.Fatal(http.ListenAndServe(":8080", handler))
}

func getUserHandler(w http.ResponseWriter, r *http.Request) {
    id := r.PathValue("id") // Go 1.22+ path parameter extraction

    user := User{ID: id, Name: "John Doe"}

    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(user)
}

func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        log.Printf("%s %s", r.Method, r.URL.Path)
        next.ServeHTTP(w, r)
    })
}

type User struct {
    ID   string `json:"id"`
    Name string `json:"name"`
}

Chi - Lightweight Router

Use When:

• Want stdlib-compatible router with better ergonomics
• Need clean middleware composition
• Prefer explicit over magic patterns
• Building moderate to complex routing structures

Strengths:

• 100% compatible with net/http
• Excellent middleware ecosystem
• Route grouping and nesting
• Context-based parameter passing
• Minimal performance overhead

Installation:

go get -u github.com/go-chi/chi/v5

Example:

package main

import (
    "encoding/json"
    "net/http"
    "github.com/go-chi/chi/v5"
    "github.com/go-chi/chi/v5/middleware"
)

func main() {
    r := chi.NewRouter()

    // Built-in middleware
    r.Use(middleware.Logger)
    r.Use(middleware.Recoverer)
    r.Use(middleware.RequestID)

    // Route grouping
    r.Route("/api/v1", func(r chi.Router) {
        r.Route("/users", func(r chi.Router) {
            r.Get("/", listUsers)
            r.Post("/", createUser)

            r.Route("/{userID}", func(r chi.Router) {
                r.Use(UserContext) // Middleware for nested routes
                r.Get("/", getUser)
                r.Put("/", updateUser)
                r.Delete("/", deleteUser)
            })
        })
    })

    http.ListenAndServe(":8080", r)
}

func UserContext(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        userID := chi.URLParam(r, "userID")
        // Load user from database, set in context
        ctx := context.WithValue(r.Context(), "user", userID)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

func getUser(w http.ResponseWriter, r *http.Request) {
    userID := r.Context().Value("user").(string)
    // Return user data
    json.NewEncoder(w).Encode(map[string]string{"id": userID})
}

Gin - High Performance Framework

Use When:

• Need maximum performance (8x faster than most frameworks)
• Want batteries-included experience
• Require built-in validation and binding
• Building JSON APIs with minimal boilerplate

Strengths:

• Extremely fast (fastest Go framework in benchmarks)
• Built-in JSON binding and validation
• Middleware ecosystem
• Group-based routing
• Custom error handling

Installation:

go get -u github.com/gin-gonic/gin

Example:

package main

import (
    "net/http"
    "github.com/gin-gonic/gin"
)

type CreateUserRequest struct {
    Name  string `json:"name" binding:"required,min=3"`
    Email string `json:"email" binding:"required,email"`
    Age   int    `json:"age" binding:"required,gte=18"`
}

func main(