It is not difficult to build a web server written in Go. The core lies in using the net/http package to implement basic services. 1. Use net/http to start the simplest server: register processing functions and listen to ports through a few lines of code; 2. Routing management: Use ServeMux to organize multiple interface paths for easy structured management; 3. Common practices: group routing by functional modules, and use third-party libraries to support complex matching; 4. Static file service: Provide HTML, CSS and JS files through http.FileServer; 5. Performance and security: Enable HTTPS, limit request body size, and set timeout to improve security and performance. After mastering these key points, it will be easier to expand functionality.

Building a web server written in Go is not difficult, especially if you are already familiar with the basic Go syntax. The net/http package in Go standard library is powerful enough to enable you to quickly start a simple HTTP service. Below are some practical steps and suggestions to help you successfully build your own web server.

Basic settings: Use net/http to start a simplest server

Go's standard library comes with a very practical HTTP package, you can run a web server with a few lines of code.

 package main

import (
    "fmt"
    "net/http"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    http.HandleFunc("/", helloHandler)
    fmt.Println("Starting server at port 8080...")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        panic(err)
    }
}

This code registers a handler that handles the root path / and listens for the local 8080 port. Visit http://localhost:8080 to see the output content.

hint:

• The first parameter of the processing function is http.ResponseWriter , which is used to write the response content.
• The second parameter is *http.Request , which can obtain the request information.
• The second parameter of http.ListenAndServe is generally passed nil , indicating that the default multiplexer (router manager) is used.

Routing Management: How to organize multiple interface paths

As the functionality increases, you may need to set different processing logic for different URL paths. Although http.HandleFunc is convenient, it is more suitable for small projects. For projects with clearer structures, it is recommended to use ServeMux :

 mux := http.NewServeMux()
mux.HandleFunc("/hello", helloHandler)
mux.HandleFunc("/about", func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "About page")
})

http.ListenAndServe(":8080", mux)

This allows centralized management of processing functions for different paths, and facilitates later replacement of middleware or custom routing logic.

Common practices:

• Group routing by functional module
• Use third-party routing libraries such as chi or gorilla/mux to achieve more complex routing matching (such as paths with parameters)

Static file service: enables the server to provide HTML, CSS and JS as well

If you want to provide static resources (such as front-end pages), you can quickly implement it through http.FileServer :

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

This code will map the static folder in the current directory to the /static/ path and automatically process the static file requests therein.

Notes:

• The path prefix needs to be removed with StripPrefix , otherwise the file cannot be found

• If you want to use a directory as the homepage, you can use:

   http.Handle("/", http.FileServer(http.Dir("./public")))

  ---

  Performance and Safety: Several Points that are Easily Neglected But Important

  Although the above method can quickly build a server, some performance and security issues need to be paid attention to in a production environment:

  • Using HTTPS: You can start HTTPS service with http.ListenAndServeTLS , or cooperate with a reverse proxy (such as Nginx)
  • Limit request body size: There is no limit by default, malicious users may upload large files and cause memory exhaustion
  • Set timeout: Create a server instance with timeout in the main function to avoid slow requests to drag down the service
  • Enable GOMAXPROCS: Although Go 1.5 enables multi-core support by default, if you deploy it on a multi-core machine, it is recommended to confirm it.

  ---

  Basically that's it. Writing a web server in Go is very fast to get started and has good performance. As long as you master the infrastructure, it will not be difficult to expand various functions in the future.

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