How to Implement a Custom 404 Error Page in Go's Standard HTTP Package?

Showing Custom 404 Error Page with Standard HTTP Package

HTTP servers typically display a basic "404 page not found" error message when a user requests a non-existent URL. To provide a more informative or customized experience, it's necessary to implement a custom error page handler.

In the standard HTTP package for Go, there exists a mechanism to handle all non-handled requests and display a custom error page. Let's delve into how to achieve this:

Custom Error Handler Function

Create a function to handle the custom error page. This function takes three arguments:

• w (http.ResponseWriter): Response writer used to send the custom error page.
• r (*http.Request): Request object for the non-existing URL.
• status (int): Status code of the error (usually http.StatusNotFound).

func errorHandler(w http.ResponseWriter, r *http.Request, status int) {
    // Set the HTTP status code.
    w.WriteHeader(status)
    // Customize the error response for specific status codes.
    if status == http.StatusNotFound {
        fmt.Fprint(w, "Custom 404 error message")
    }
}

Setting the Custom Error Handler

The error handler function needs to be linked to the HTTP server. This is done in the http.ListenAndServe function, which starts the server on a specified port.

http.ListenAndServe(":12345", nil)

Replace nil with a custom HTTP request handler that handles all requests.

http.ListenAndServe(":12345", new(http.ServeMux))

In ServeMux, add the original route handlers for specific URLs.

mux := http.NewServeMux()
mux.HandleFunc("/smth/", smthHandler)
mux.HandleFunc("/", homeHandler)

http.ListenAndServe(":12345", mux)

Finally, add a NotFoundHandler to the ServeMux to handle all other URLs not handled by the specific route handlers.

mux.NotFoundHandler = http.HandlerFunc(errorHandler)

Example Code

The complete example code that implements the above approach is as follows:

package main

import (
    "fmt"
    "net/http"
)

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/smth/", smthHandler)
    mux.HandleFunc("/", homeHandler)
    mux.NotFoundHandler = http.HandlerFunc(errorHandler)

    http.ListenAndServe(":12345", mux)
}

func smthHandler(w http.ResponseWriter, r *http.Request) {
    if r.URL.Path != "/smth/" {
        errorHandler(w, r, http.StatusNotFound)
        return
    }
    fmt.Fprint(w, "Welcome to smth")
}

func homeHandler(w http.ResponseWriter, r *http.Request) {
    if r.URL.Path != "/" {
        errorHandler(w, r, http.StatusNotFound)
        return
    }
    fmt.Fprint(w, "Welcome home")
}

func errorHandler(w http.ResponseWriter, r *http.Request, status int) {
    w.WriteHeader(status)
    if status == http.StatusNotFound {
        fmt.Fprint(w, "Custom 404 error message")
    }
}

This code defines route handlers for specific URLs (/smth/ and /) and assigns a custom error handler function (errorHandler) to handle all other non-handled requests. When a user tries to access a non-existing URL, the custom 404 error page will be displayed instead of the default "404 page not found" message.

The above is the detailed content of How to Implement a Custom 404 Error Page in Go's Standard HTTP Package?. For more information, please follow other related articles on the PHP Chinese website!