Top 5 Golang HTTP packages – HTTP frameworks

1. net/http

The net/http package is the backbone of HTTP networking in Go. It is the default library that comes right out of the box with Go and provides robust tools for building web servers and clients. Its simplicity and rich features make it a great starting point for those learning Golang or developing simple web services.

import (
    "fmt"
    "net/http"
)

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

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

Output: When you run the server and navigate to http://localhost:8080/, you will be greeted with a “Hello, World!” message.

2. Gorilla Mux

Gorilla Mux is a powerful URL router and dispatcher for Go. It extends the net/http package to offer more flexibility when handling URL routes, making it a favorite among developers looking for finer control and additional features such as named routes, variables in the URL, and subrouters.

import (
    "net/http"
    "github.com/gorilla/mux"
)

func main() {
    r := mux.NewRouter()
    r.HandleFunc("/", HomeHandler)
    http.Handle("/", r)
}

func HomeHandler(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("Gorilla!\n"))
}

Output: Accessing http://localhost:8080/ will display “Gorilla!”

3. Gin-Gonic

import "github.com/gin-gonic/gin"

func main() {
    r := gin.Default()
    r.GET("/", func(c *gin.Context) {
        c.String(200, "Hello, World!")
    })
    r.Run() // listen and serve on 0.0.0.0:8080
}

Output: “Hello, World!” is sent to the client upon visiting http://localhost:8080/.

4. Echo

Echo is a high performance, extensible, minimalistic Go web framework. It provides a streamlined interface for handling HTTP requests and is optimized for speed. Echo features include routing, middleware support, and template rendering, among others.

import (
    "net/http"
    "github.com/labstack/echo/v4"
)

func main() {
    e := echo.New()
    e.GET("/", func(c echo.Context) error {
        return c.String(http.StatusOK, "Hello, Echo!")
    })
    e.Start(":8080")
}

Output: Navigating to http://localhost:8080/ will present you with “Hello, Echo!”.

5. Fasthttp

Fasthttp is an alternative HTTP server implementation for Go that claims to be faster and to use less memory than the standard net/http package, especially at scale. It’s well-suited for high-performance applications that do not require HTTP/2 support.

import (
    "fmt"
    "github.com/valyala/fasthttp"
)

func main() {
    fasthttp.ListenAndServe(":8080", func(ctx *fasthttp.RequestCtx) {
        fmt.Fprintf(ctx, "Hello, fasthttp!")
    })
}

Output: You are greeted with “Hello, fasthttp!” on http://localhost:8080/.

Summary

Whether you’re building simple web services or complex web applications in Go, there is an HTTP package or framework to suit your needs. While the standard net/http package covers the basics and is an excellent choice for many use cases, Go’s rich ecosystem offers enhanced alternatives like Gorilla Mux for routing, Gin-Gonic and Echo for high-performance web frameworks, and Fasthttp for speed-critical applications. Choose the right golang http package that aligns best with your project requirements and you’ll be well on your way to developing powerful, performant web applications.

References

• net/http
• Gorilla Mux
• Gin-Gonic
• Echo
• Fasthttp