**Course Title:** Mastering Go: From Basics to Advanced Development **Section Title:** Building Web Applications with Go **Topic:** Routing and Handling HTTP Requests ### Introduction In the previous topic, we introduced the net/http package for web development. In this topic, we will explore how to route and handle HTTP requests using the net/http package. ### Routing in Go Routing is the process of mapping an incoming HTTP request to a specific handler function. Go's net/http package provides a built-in router, but it's very basic. For production applications, you'll likely want to use a third-party router like Gorilla or Go-Router. ### Using the net/http Package for Routing The net/http package provides a basic router using the `http.HandleFunc()` function. Here's an example of how to use it to handle GET and POST requests: ```go package main import ( "fmt" "net/http" ) func helloHandler(w http.ResponseWriter, r *http.Request) { fmt.Fprint(w, "Hello, World!") } func formHandler(w http.ResponseWriter, r *http.Request) { if r.Method == "POST" { fmt.Fprint(w, "Form submitted successfully!") } else { http.Error(w, "Invalid request method", http.StatusBadRequest) } } func main() { http.HandleFunc("/", helloHandler) http.HandleFunc("/form", formHandler) http.ListenAndServe(":8080", nil) } ``` This example creates a server that handles GET requests to the root URL ("/") and POST requests to the "/form" URL. ### Using a Third-Party Router As mentioned earlier, Go's net/http package is very basic, so for more complex routing needs, you'll want to use a third-party router. Here's an example of how to use Gorilla's router package to handle GET and POST requests: ```go package main import ( "fmt" "net/http" "github.com/gorilla/mux" ) func helloHandler(w http.ResponseWriter, r *http.Request) { fmt.Fprint(w, "Hello, World!") } func formHandler(w http.ResponseWriter, r *http.Request) { if r.Method == "POST" { fmt.Fprint(w, "Form submitted successfully!") } else { http.Error(w, "Invalid request method", http.StatusBadRequest) } } func main() { router := mux.NewRouter() router.HandleFunc("/", helloHandler).Methods("GET") router.HandleFunc("/form", formHandler).Methods("POST") http.ListenAndServe(":8080", router) } ``` This example creates a router that handles GET requests to the root URL ("/") and POST requests to the "/form" URL. Note that we've used Gorilla's `mux` package to create a new router. ### Handling HTTP Requests Once you've set up your routing, you can start handling HTTP requests. Here's an example of how to handle GET and POST requests: ```go package main import ( "encoding/json" "fmt" "net/http" ) type User struct { Name string `json:"name"` Email string `json:"email"` } func getUserHandler(w http.ResponseWriter, r *http.Request) { user := User{ Name: "John Doe", Email: "john@example.com", } json.NewEncoder(w).Encode(user) } func createUserHandler(w http.ResponseWriter, r *http.Request) { var user User err := json.NewDecoder(r.Body).Decode(&user) if err != nil { http.Error(w, "Invalid request body", http.StatusBadRequest) return } fmt.Fprint(w, "User created successfully!") } func main() { http.HandleFunc("/user", getUserHandler) http.HandleFunc("/create-user", createUserHandler) http.ListenAndServe(":8080", nil) } ``` This example creates a server that handles GET requests to the "/user" URL and POST requests to the "/create-user" URL. The `getUserHandler` function returns a JSON object containing a user's details, while the `createUserHandler` function creates a new user based on the request body. ### Best Practices for Routing and Handling HTTP Requests * Use a third-party router like Gorilla or Go-Router for more complex routing needs. * Always validate request bodies to prevent invalid data from entering your application. * Use JSON encoding to return structured data in responses. * Always handle request methods explicitly to prevent unintended behavior. ### Conclusion In this topic, we explored how to route and handle HTTP requests using Go's net/http package. We also touched on using a third-party router like Gorilla for more complex routing needs. When building production-grade web applications, remember to always validate request bodies, use JSON encoding to return structured data, and handle request methods explicitly. ### What's Next? In the next topic, we'll explore how to work with JSON and XML data in Go. You'll learn how to encode and decode JSON data, and how to parse XML data using Go's standard library. If you have any questions or need help with any of the concepts covered in this topic, please leave a comment below. For more information on the topics covered, feel free to visit the following links: - [Go Documentation](https://golang.org/doc/) - [Gorilla Router](https://github.com/gorilla/mux) - [Go-Router](https://github.com/go-kratos/kratos/tree/main/pkg/router) References: - [The Go Programming Language](https://golang.org/) - [Gorilla Router Documentation](https://godoc.org/github.com/gorilla/mux)