Building REST APIs in Go

# CHAPTER 23

Building REST APIs in Go #

1. Introduction #

2. Learning Objectives #

• Use the net/http package.

• Create an HTTP Web Server.

• Define API Routes (Endpoints).

• Return JSON responses to the client.

• Understand http.ResponseWriter and http.Request.

3. The net/http Package #

package main

import (
    "fmt"
    "net/http"
)

// 1. The Handler Function
func homePage(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Welcome to the Go Web Server!")
}

func main() {
    // 2. Define the Route
    http.HandleFunc("/", homePage)

    // 3. Start the Server on Port 8080
    fmt.Println("Server starting on http://localhost:8080...")
    http.ListenAndServe(":8080", nil) // Blocks forever, listening for traffic
}

*If you run this code, open your web browser and visit http://localhost:8080. You will see your text!*

4. Understanding Handlers #

1. 1. w http.ResponseWriter: The tool you use to write the response back to the client's browser.

1. 2. r *http.Request: A pointer holding all the details of the incoming request (the URL, headers, POST data, etc.).

5. Building a JSON REST API #

package main

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

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

func getUsers(w http.ResponseWriter, r *http.Request) {
    // 1. Tell the browser we are sending JSON, not plain text
    w.Header().Set("Content-Type", "application/json")

    // 2. Create some dummy data
    users := []User{
        {ID: 1, Name: "Alice"},
        {ID: 2, Name: "Bob"},
    }

    // 3. Marshal the struct into JSON bytes, and Write it to the ResponseWriter
    json.NewEncoder(w).Encode(users)
}

func main() {
    http.HandleFunc("/api/users", getUsers)
    http.ListenAndServe(":8080", nil)
}

*Visit http://localhost:8080/api/users and you will see a beautifully formatted JSON array!*

6. HTTP Methods (GET vs POST) #

func usersHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method == http.MethodGet {
        // Handle GET
        w.Write([]byte("Returning users..."))
    } else if r.Method == http.MethodPost {
        // Handle POST
        w.Write([]byte("Creating a new user..."))
    } else {
        // Handle Invalid Methods
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
    }
}

7. Why Go Web Servers are Fast (Goroutines) #

8. Common Mistakes #

• Forgetting to set Content-Type: If you return JSON but forget w.Header().Set("Content-Type", "application/json"), some strict front-end frameworks (like React or Angular) might fail to parse the data because they think it's plain text.

• Writing to Headers AFTER sending data: You must configure status codes and headers *before* you use w.Write(). Once data is sent, the headers are locked.

9. Best Practices #

• Third-Party Routers: The standard net/http package is great, but routing complex URLs with variables (like /api/users/{id}) is slightly tedious. In real-world enterprise apps, developers usually import a lightweight router package like Gorilla Mux or Chi.

10. Exercises #

1. 1. Create a server that listens on port 9000.

1. 2. Create an endpoint /api/status that returns a JSON object {"status": "API is healthy!"}.

1. 3. Test it in your browser.

11. MCQs with Answers & Explanations #

12. Interview Preparation #

1. 1. Explain how Go's net/http package handles concurrency under the hood. (Answer: Auto-spawning Goroutines per request).

1. 2. Why is it recommended to use a router like Gorilla Mux or Chi over the standard library multiplexer for complex APIs? (Answer: Easier handling of URL path parameters and HTTP method filtering).

13. Summary #

14. Next Chapter Recommendation #