Go HTTP Package

The built-in net/http package in the Go language is the core component for building network services. It provides a concise, efficient, and feature-complete implementation of HTTP/1.1 clients and servers. Unlike other high-level web frameworks (such as Gin or Echo), this package does not rely on external libraries to run, giving it unique advantages in microservices architectures and high-concurrency scenarios. The net/http package supports standard RESTful API design patterns and includes built-in capabilities for automatic compression, content negotiation, and HTTP/2 protocol support. For developers building high-performance network services from scratch, a deep understanding and mastery of this standard library is an essential skill.
The first step in writing a server using the net/http package is typically initializing a listener (Listener). Go provides two primary approaches: either directly invoking the http.ListenAndServe() function or using the http.Server struct for more granular control configuration. The latter allows developers to customize key parameters such as timeout durations, read buffer sizes, and maximum header lengths, which is crucial for production environments.

Below is a complete example code based on http.Server, demonstrating how to define routes and start the service:

package main

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

// Manual handler function for handling GET /hello requests
func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello from Go HTTP Server!")
}

func main() {
    // Define a route mapping table, associating paths with handlers
    http.HandleFunc("/hello", helloHandler)
    
    // Create and start the server instance
    server := &http.Server{
        Addr:         ":8080", // Listening address and port
        ReadTimeout:  15 * time.Second,
        WriteTimeout: 15 * time.Second,
    }

    fmt.Println("Server starting on :8080...")
    if err := server.ListenAndServe(); err != nil {
        panic(err) // If an error occurs, panic and stop the server
    }
}

In the code above, we first define a simple handler function helloHandler. This function accepts two parameters: a response writer (ResponseWriter) and a request object (Request). By invoking the Fprintf method, the string is directly output to the client. Subsequently, in the main function, the route path /hello is registered to the corresponding handler using http.HandleFunc. Finally, the Server struct is instantiated and the listening service is started.

Detailed Explanation of HTTP Response and Request Objects

The key to understanding the net/http package lies in mastering its core data structures: ResponseWriter and Request (along with their fields). These two types encapsulate all information required for processing network interactions.

ResponseWriter (http.ResponseWriter)
This is the interface through which the server sends data to the client, simulating a standard HTTP response object. Developers can use this struct to set status codes, write response headers, and construct response body content. It is worth noting that Go's WriteHeader method must be called before any write operations, and once header information is set, it cannot be changed again.

Request (http.Request)
The request object contains all details initiated by the client, including the URL, HTTP method (GET/POST, etc.), query parameters, and custom request header fields. By parsing these fields, servers can flexibly handle different business logic requirements. For example, one can retrieve user input search keywords using r.URL.Query(), or read the Content-Type header to determine the format of uploaded files.

HTTP Client and Concurrent Request Management

In addition to building server-side applications, Go's net/http package also provides powerful client capabilities. Through functions like http.Get, http.Post, http.Head, or by creating custom Client instances, developers can easily initiate synchronous or non-blocking network requests to external APIs. When handling large-scale concurrent data scraping, utilizing Go's native Goroutines combined with Channels for flow control is a key strategy for achieving high throughput.

// Example: Sending a POST request using http.Client and processing the response
func postRequest() {
    url := "https://api.example.com/data"
    
    req, err := http.NewRequest("POST", url, bytes.NewBufferString(`{"key": "value"}`))
    if err != nil {
        log.Fatal(err)
    }

    client := &http.Client{Timeout: 10 * time.Second} // Set timeout to prevent indefinite waiting
    
    resp, err := client.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

    bodyBytes, _ := io.ReadAll(resp.Body)
    fmt.Println(string(bodyBytes))
    
    if resp.StatusCode == http.StatusOK {
        fmt.Println("Request successful")
    } else {
        fmt.Printf("Request failed, status code: %d\n", resp.StatusCode)
    }
}

This code demonstrates how to construct a standard POST request. We first create a new Request object and specify JSON data as the Body, then configure a Client instance with a timeout setting to avoid network blocking. Finally, the Do() method is called to execute the actual network operation, and the result success is determined based on the returned status code. This pattern is not only applicable to simple API calls but also forms the foundation for inter-service communication in distributed systems.

By mastering Go's built-in HTTP package, developers can implement complex functional requirements with minimal code overhead. Whether building high-concurrency microservice platforms or developing lightweight network tools, understanding its underlying mechanisms is an important cornerstone for improving coding quality.