Golang Backend Development

# Go Backend Development Examples

> 25+ practical, production-ready examples demonstrating Go backend patterns, from basic HTTP servers to advanced microservices.

## Table of Contents

1. [Basic Web Server](#1-basic-web-server)
2. [JSON REST API](#2-json-rest-api)
3. [Middleware Chain](#3-middleware-chain)
4. [Context-Based Timeout](#4-context-based-timeout)
5. [Worker Pool Pattern](#5-worker-pool-pattern)
6. [Pipeline Pattern](#6-pipeline-pattern)
7. [Fan-Out/Fan-In Pattern](#7-fan-outfan-in-pattern)
8. [Database CRUD Operations](#8-database-crud-operations)
9. [Transaction Handling](#9-transaction-handling)
10. [Graceful Shutdown](#10-graceful-shutdown)
11. [Rate Limiting](#11-rate-limiting)
12. [Circuit Breaker](#12-circuit-breaker)
13. [WebSocket Server](#13-websocket-server)
14. [gRPC Service](#14-grpc-service)
15. [Caching Layer](#15-caching-layer)
16. [Event-Driven Architecture](#16-event-driven-architecture)
17. [File Upload Handler](#17-file-upload-handler)
18. [Authentication Middleware](#18-authentication-middleware)
19. [Structured Logging](#19-structured-logging)
20. [Health Check System](#20-health-check-system)
21. [Concurrent File Processing](#21-concurrent-file-processing)
22. [Service Discovery](#22-service-discovery)
23. [Message Queue Consumer](#23-message-queue-consumer)
24. [Background Job Processor](#24-background-job-processor)
25. [API Gateway Pattern](#25-api-gateway-pattern)

---

## 1. Basic Web Server

A minimal HTTP server demonstrating Go's built-in web capabilities.

```go
package main

import (
    "fmt"
    "log"
    "net/http"
)

func main() {
    // Register handler function
    http.HandleFunc("/", handleRoot)
    http.HandleFunc("/health", handleHealth)

    // Start server
    log.Println("Server starting on :8080")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        log.Fatal(err)
    }
}

func handleRoot(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func handleHealth(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusOK)
    fmt.Fprintf(w, "OK")
}
```

**Use Case**: Simple web services, health check endpoints, landing pages

**Key Concepts**:
- `http.HandleFunc` registers handlers
- `http.ListenAndServe` starts the server
- Handler functions receive `ResponseWriter` and `*Request`

---

## 2. JSON REST API

Complete RESTful API with JSON encoding/decoding.

```go
package main

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

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

type UserStore struct {
    users map[int]*User
    mu    sync.RWMutex
    nextID int
}

func NewUserStore() *UserStore {
    return &UserStore{
        users: make(map[int]*User),
        nextID: 1,
    }
}

func (s *UserStore) Create(user *User) *User {
    s.mu.Lock()
    defer s.mu.Unlock()
    user.ID = s.nextID
    s.nextID++
    s.users[user.ID] = user
    return user
}

func (s *UserStore) Get(id int) (*User, bool) {
    s.mu.RLock()
    defer s.mu.RUnlock()
    user, ok := s.users[id]
    return user, ok
}

func (s *UserStore) List() []*User {
    s.mu.RLock()
    defer s.mu.RUnlock()
    users := make([]*User, 0, len(s.users))
    for _, user := range s.users {
        users = append(users, user)
    }
    return users
}

func main() {
    store := NewUserStore()

    http.HandleFunc("/users", func(w http.ResponseWriter, r *http.Request) {
        switch r.Method {
        case http.MethodGet:
            handleListUsers(w, r, store)
        case http.MethodPost:
            handleCreateUser(w, r, store)
        default:
            http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        }
    })

    http.HandleFunc("/users/", func(w http.ResponseWriter, r *http.Request) {
        if r.Method == http.MethodGet {
            handleGetUser(w, r, store)
        } else {
            http.Error(w, "Method not allowed", http.S