Import the net/http package and define the processing function, use http.HandleFunc to register the processor of the root path, and then call http.ListenAndServe(":8080", nil) to start the server; 2. Register independent processors for different paths such as "/about" through http.HandleFunc to achieve multi-routing; 3. Use http.FileServer to combine http.StripPrefix and http.Handle to provide access to the files in the static/ directory through the /static/ path, and optionally define homeHandler to return to the main page; 4. Use http.NewServeMux to create a router multiplexer, and use custom http.Server instances to obtain advanced configuration control capabilities such as timeout and TLS; in summary, a lightweight web server with routing, static file services and extensible configuration can be built through the Go standard library net/http, which is suitable for learning and simple applications, without the need for third-party frameworks.

Building a simple web server in Golang is straightforward thanks to the net/http package, which is part of Go's standard library. You don't need external dependencies for basic functionality. Here's how to do it step by step.

? 1. Set up a basic HTTP server

Start by importing the required packages and defining a handler function:

 package main

import (
    "fmt"
    "net/http"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World! This is a simple Go web server.")
}

func main() {
    http.HandleFunc("/", helloHandler)
    fmt.Println("Server starting on :8080...")
    http.ListenAndServe(":8080", nil)
}

What this does:

• http.HandleFunc("/", helloHandler) registers the helloHandler function to handle requests to the root path / .
• http.ListenAndServe(":8080", nil) starts the server on port 8080.
• The helloHandler writes a simple response to the client.

Run it with:

 go run main.go

Then visit http://localhost:8080 in your browser.

? 2. Add multiple routes

You can define different handlers for different paths:

 func aboutHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "About page - Built with Go!")
}

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

    fmt.Println("Server running on http://localhost:8080")
    http.ListenAndServe(":8080", nil)
}

Now:

• GET / → "Hello, World!"
• GET /about → "About page - Built with Go!"

? 3. Serve static files (like HTML, CSS, JS)

Suppose you have a folder static/ with an index.html file.

 func main() {
    fs := http.FileServer(http.Dir("static/"))
    http.Handle("/static/", http.StripPrefix("/static/", fs))

    http.HandleFunc("/", homeHandler) // Optional: render home page

    fmt.Println("Server on :8080")
    http.ListenAndServe(":8080", nil)
}

With this:

• Files in static/ are served under /static/...
• For example, static/index.html → accessible at http://localhost:8080/static/index.html

And your homeHandler could be:

 func homeHandler(w http.ResponseWriter, r *http.Request) {
    http.ServeFile(w, r, "static/index.html")
}

? 4. Use a custom server for better control

Instead of http.ListenAndServe , use http.Server for timeouts and graceful shutdowns:

 func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", helloHandler)
    mux.HandleFunc("/about", aboutHandler)

    server := &http.Server{
        Addr: ":8080",
        Handler: mux,
    }

    fmt.Println("Server starting on :8080")
    if err := server.ListenAndServe(); err != nil {
        fmt.Printf("Server failed: %v\n", err)
    }
}

This gives you more control over configuration (like timeouts, TLS, etc.).

Tips & Best Practices

• Always validate input in real apps (headers, query params, body).
• Avoid nil handler in ListenAndServe if using a custom ServeMux .
• For production, consider using routers like gorilla/mux or chi , but for learning or simple APIs, net/http is perfect.
• Handle errors properly (eg, file not found, bad requests).

That's it — you've built a working web server in Go with routing and static file support. It's minimal, fast, and doesn't need a framework.

The above is the detailed content of How to build a simple web server in Golang?. For more information, please follow other related articles on the PHP Chinese website!