Handling Multiple Routes

This snippet expands on the basic server example by demonstrating how to handle different routes (URLs) within your application. It introduces the concept of using multiple handlers to respond to different requests.

Code Snippet

This code defines two handlers: `homeHandler` for the root path ('/') and `aboutHandler` for the '/about' path. `http.HandleFunc` is used to register each handler with its respective path. When a request is made to '/', `homeHandler` is executed, and when a request is made to '/about', `aboutHandler` is executed. The `main` function starts the server and listens for incoming requests on port 8080.

package main

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

func homeHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Welcome to the home page!")
}

func aboutHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "About us: We are a team of developers.")
}

func main() {
	http.HandleFunc("/", homeHandler)
	http.HandleFunc("/about", aboutHandler)

	fmt.Println("Server starting on port 8080")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

Concepts Behind the Snippet

The core concept is URL routing. The HTTP server examines the URL of the incoming request and dispatches the request to the appropriate handler based on the URL's path. `http.HandleFunc` is a convenient way to register handlers for specific paths. More sophisticated routing can be achieved using a web framework.

Real-Life Use Case

In a real-world web application, you'll have multiple routes to handle different functionalities, such as displaying a homepage, showing product details, processing form submissions, and serving static files. This snippet provides the foundation for building such an application.

Best Practices

• Route Organization: Group related routes under a common prefix (e.g., `/api/users`, `/api/products`).
• Error Handling: Implement proper error handling for each handler function.
• Middleware: Use middleware to handle common tasks like authentication, logging, and request validation.

Interview Tip

Be able to explain how the server determines which handler to execute based on the URL. Also, understand the limitations of using `http.HandleFunc` directly and when a web framework might be a better choice.

When to Use Them

Use this approach when you need to handle a small number of routes and don't want the overhead of a full-fledged web framework. It's suitable for simple APIs or web applications.

Alternatives

• Web Frameworks: Gin, Echo, and Fiber provide more advanced routing features, such as route parameters, regular expression matching, and route groups.
• Custom Router: You can implement your own router using a `switch` statement or a more complex data structure.

Pros

• Simple Routing: Provides basic routing functionality without external dependencies.
• Easy to Understand: The code is straightforward and easy to grasp.

Cons

• Limited Routing Capabilities: Lacks advanced routing features like route parameters and regular expression matching.
• Code Duplication: Can lead to code duplication if you have many similar routes.