Building an Efficient REST API with Go and Gorilla MUX

Building a REST API in Go is straightforward with Gorilla Mux, a powerful and flexible router. It provides robust routing capabilities, middleware support, and easy parameter handling.

This article walks through setting up an efficient REST API using Go and Gorilla Mux, covering routing, request handling, middleware, and best practices.

Before starting, ensure you have Go installed. Then, initialize a new Go module and install Gorilla Mux.

go mod init example.com/myapi
go get -u github.com/gorilla/mux

Let's create a basic API with Gorilla Mux that supports retrieving, creating, updating, and deleting resources.

package main

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

	"github.com/gorilla/mux"
)

func homeHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintln(w, "Welcome to the API")
}

func main() {
	router := mux.NewRouter()
	router.HandleFunc("/", homeHandler).Methods("GET")

	log.Println("Server running on port 8080")
	log.Fatal(http.ListenAndServe(":8080", router))
}

Explanation:

• We create a new router using mux.NewRouter().
• The HandleFunc method maps routes to handlers.
• The server listens on port 8080.

A REST API typically supports CRUD (Create, Read, Update, Delete) operations. Let's define a simple resource: Books.

type Book struct {
	ID     string `json:"id"`
	Title  string `json:"title"`
	Author string `json:"author"`
}

var books = []Book{
	{ID: "1", Title: "Go Programming", Author: "John Doe"},
	{ID: "2", Title: "RESTful APIs in Go", Author: "Jane Smith"},
}

func getBooks(w http.ResponseWriter, r *http.Request) {
	json.NewEncoder(w).Encode(books)
}

func getBook(w http.ResponseWriter, r *http.Request) {
	params := mux.Vars(r)
	for _, book := range books {
		if book.ID == params["id"] {
			json.NewEncoder(w).Encode(book)
			return
		}
	}
	http.NotFound(w, r)
}

func createBook(w http.ResponseWriter, r *http.Request) {
	var newBook Book
	json.NewDecoder(r.Body).Decode(&newBook)
	books = append(books, newBook)
	w.WriteHeader(http.StatusCreated)
	json.NewEncoder(w).Encode(newBook)
}

func deleteBook(w http.ResponseWriter, r *http.Request) {
	params := mux.Vars(r)
	for index, book := range books {
		if book.ID == params["id"] {
			books = append(books[:index], books[index+1:]...)
			w.WriteHeader(http.StatusNoContent)
			return
		}
	}
	http.NotFound(w, r)
}

Now, let's register these handlers in the router.

func main() {
	router := mux.NewRouter()

	router.HandleFunc("/books", getBooks).Methods("GET")
	router.HandleFunc("/books/{id}", getBook).Methods("GET")
	router.HandleFunc("/books", createBook).Methods("POST")
	router.HandleFunc("/books/{id}", deleteBook).Methods("DELETE")

	log.Println("Server running on port 8080")
	log.Fatal(http.ListenAndServe(":8080", router))
}

Key Features:

• GET /books - Fetch all books.
• GET /books/{id} - Fetch a specific book by ID.
• POST /books - Create a new book.
• DELETE /books/{id} - Remove a book by ID.

Middleware in Gorilla Mux allows intercepting requests before they reach handlers.

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

func main() {
	router := mux.NewRouter()
	router.Use(loggingMiddleware)

	router.HandleFunc("/books", getBooks).Methods("GET")
	router.HandleFunc("/books/{id}", getBook).Methods("GET")
	router.HandleFunc("/books", createBook).Methods("POST")
	router.HandleFunc("/books/{id}", deleteBook).Methods("DELETE")

	log.Println("Server running on port 8080")
	log.Fatal(http.ListenAndServe(":8080", router))
}

Gorilla Mux makes it easy to parse query parameters.

func getBooksFiltered(w http.ResponseWriter, r *http.Request) {
	author := r.URL.Query().Get("author")
	if author == "" {
		json.NewEncoder(w).Encode(books)
		return
	}

	var filteredBooks []Book
	for _, book := range books {
		if book.Author == author {
			filteredBooks = append(filteredBooks, book)
		}
	}

	json.NewEncoder(w).Encode(filteredBooks)
}

Example Usage:

• GET /books?author=John+Doe - Returns books written by "John Doe".

• Use middleware for logging, authentication, and request validation.
• Return proper status codes (e.g., 201 Created, 404 Not Found).
• Use structured error handling to improve API responses.
• Paginate large responses to prevent performance issues.
• Secure endpoints using authentication (e.g., JWT, OAuth).
• Use http.TimeoutHandler to prevent slow responses from blocking the server.

Gorilla Mux is a powerful routing library for building efficient REST APIs in Go. It provides features like path variables, middleware, and flexible routing. By following best practices and structuring your API properly, you can create scalable and maintainable web services.

This guide covered setting up a basic API, defining routes, handling CRUD operations, adding middleware, and implementing query parameters. With this foundation, you can expand your API with authentication, database integration, and other advanced features.