What Is Middleware in a Go Web Application?

In Go’s built-in net/http package, middleware is a function that:

• Wraps your main handler

• Runs before the actual handler

• Optionally runs after the handler

• Adds cross-cutting features (logging, auth, tracing, monitoring)

Middleware is basically:

A function that intercepts an HTTP request before it reaches your handler.

Just like layers of an onion:

Client → Middleware → Handler → Response

---

⭐ Common Middleware Examples

• Logging incoming requests

• Authentication & authorization

• Request validation

• Setting headers

• Rate limiting

• Panic recovery

• CORS handling

• Request tracing (OpenTelemetry)

---

1️⃣ Text-Based Diagram: How Middleware Works

┌──────────────────────────┐
│        Client             │
└───────────────▲──────────┘
                │ request
                ▼
       ┌───────────────────┐
       │    Middleware     │  ← logs, checks, sets headers
       └───────▲───────────┘
               │ calls next()
               ▼
     ┌─────────────────────┐
     │      Handler        │  ← business logic
     └─────────▲───────────┘
               │ response
               ▼
┌──────────────────────────┐
│        Client             │
└──────────────────────────┘

---

2️⃣ Full Working Example: Go HTTP Server + Middleware + Handler + Resolver

We will build:

• main.go → main entry

• middleware.go → middleware

• resolver.go → business resolver

• handler.go → handler (controller)

• Dockerfile → run as a container

---

📁 Folder Structure

go-middleware-demo/
│
├── main.go
├── handler.go
├── resolver.go
├── middleware.go
└── Dockerfile

---

3️⃣ Code: middleware.go

package main

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

// LoggingMiddleware logs each incoming request.
func LoggingMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

		start := time.Now()

		// BEFORE handler
		log.Printf("Incoming request → %s %s", r.Method, r.URL.Path)

		// Call next handler
		next.ServeHTTP(w, r)

		// AFTER handler
		log.Printf("Completed → %s %s (%v)", r.Method, r.URL.Path, time.Since(start))
	})
}

---

4️⃣ Code: resolver.go (business logic layer)

package main

// Resolver simulates fetching data or doing business logic.
type Resolver struct{}

func (r *Resolver) GetGreeting(name string) string {
	if name == "" {
		name = "Guest"
	}
	return "Hello, " + name + "! Welcome to Go Middleware Demo."
}

---

5️⃣ Code: handler.go (HTTP handler)

package main

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

type Handler struct {
	Resolver *Resolver
}

func (h *Handler) GreetingHandler(w http.ResponseWriter, r *http.Request) {
	name := r.URL.Query().Get("name")
	message := h.Resolver.GetGreeting(name)

	resp := map[string]string{
		"message": message,
	}

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

---

6️⃣ Code: main.go (server setup)

package main

import (
	"log"
	"net/http"
)

func main() {

	resolver := &Resolver{}
	handler := &Handler{Resolver: resolver}

	mux := http.NewServeMux()
	mux.Handle("/greet", LoggingMiddleware(http.HandlerFunc(handler.GreetingHandler)))

	log.Println("Server started on port 8080")
	err := http.ListenAndServe(":8080", mux)
	if err != nil {
		log.Fatal(err)
	}
}

---

7️⃣ Test the Server Locally

Run the app:

go run .

Test using browser or curl:

http://localhost:8080/greet?name=Vinod

Output:

{
  "message": "Hello, Vinod! Welcome to Go Middleware Demo."
}

Logs:

Incoming request → GET /greet
Completed → GET /greet (1.2ms)

---

8️⃣ Add Docker Support (Dockerfile)

Create Dockerfile:

FROM golang:1.22-alpine AS build

WORKDIR /app

COPY . .

RUN go mod init go-middleware-demo || true
RUN go mod tidy
RUN go build -o server .

FROM alpine:3.19
WORKDIR /app
COPY --from=build /app/server .

EXPOSE 8080

CMD ["./server"]

---

9️⃣ Build & Run the Docker Container

Build:

docker build -t go-middleware-demo .

Run:

docker run -p 8080:8080 go-middleware-demo

Test:

http://localhost:8080/greet?name=Vinod

---

🔟 Text Diagram: Overall Architecture

                    ┌────────────┐
                    │   Client    │
                    └──────▲──────┘
                           │
                           ▼
                ┌──────────────────────┐
                │    Middleware         │
                │ - logging             │
                │ - authentication      │
                │ - rate limiting       │
                └─────────▲────────────┘
                          │
                          ▼
                ┌──────────────────────┐
                │     Handler          │
                │  - HTTP controller   │
                │  - calls resolver    │
                └─────────▲────────────┘
                          │
                          ▼
                ┌──────────────────────┐
                │      Resolver        │
                │   - business logic   │
                └──────────────────────┘

---

📝 Source code

https://github.com/kkvinodkumaran/go-middleware-demo 

 

📝 Summary (Interview-Ready)

✔ What is middleware in Go?

A function that wraps your handler to execute logic before/after request processing.

✔ What can middleware do?

• Logging

• Auth

• Rate limiting

• Setting headers

• Error handling

• Tracing

✔ Our example includes:

• Logging middleware

• Handler

• Resolver

• HTTP server

• Dockerfile