9 Web Development With Go

Web development with Go has become increasingly popular due to its simplicity, performance, and concurrency support. In this post, we’ll explore how to build web applications using Go, covering topics such as routing, handling HTTP requests, serving static files, and working with databases.

Setting Up a Basic Web Server

To start building web applications in Go, you need to set up a basic web server. You can use the built-in net/http package, which provides everything you need to handle HTTP requests and serve HTTP responses. Here’s a simple example:

package main

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)
}

In this example, we define a handler function that writes “Hello, World!” to the HTTP response. We then use http.HandleFunc to associate this handler function with the root URL path ("/"), and http.ListenAndServe to start the HTTP server on port 8080.

Routing

Routing is the process of matching incoming HTTP requests to the appropriate handler functions based on the request URL. In Go, you can use the mux package, which provides a powerful and flexible router. Here’s an example:

package main

import (
    "fmt"
    "net/http"

    "github.com/gorilla/mux"
)

func homeHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Home Page")
}

func aboutHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "About Page")
}

func main() {
    router := mux.NewRouter()
    router.HandleFunc("/", homeHandler)
    router.HandleFunc("/about", aboutHandler)

    http.ListenAndServe(":8080", router)
}

In this example, we use the mux.NewRouter function to create a new router, and then use router.HandleFunc to define routes and associate them with handler functions.

Serving Static Files

Static files such as HTML, CSS, and JavaScript are an essential part of web development. In Go, you can serve static files using the http.FileServer handler. Here’s an example:

package main

import (
    "net/http"
)

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

    http.ListenAndServe(":8080", nil)
}

In this example, we use http.FileServer to create a file server that serves files from the “static” directory. We then use http.Handle to register this file server handler with a specific URL path prefix ("/static/").

Working With Databases

Go has excellent support for working with databases, with libraries available for popular databases like MySQL, PostgreSQL, and SQLite. Here’s a simple example of working with a SQLite database using the database/sql package:

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/mattn/go-sqlite3"
)

func main() {
    db, err := sql.Open("sqlite3", "test.db")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer db.Close()

    _, err = db.Exec("CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)")
    if err != nil {
        fmt.Println(err)
        return
    }

    _, err = db.Exec("INSERT INTO users (name) VALUES (?)", "Alice")
    if err != nil {
        fmt.Println(err)
        return
    }

    rows, err := db.Query("SELECT id, name FROM users")
    if err != nil {
        fmt.Println(err)
        return
    }
    defer rows.Close()

    for rows.Next() {
        var id int
        var name string
        err = rows.Scan(&id, &name)
        if err != nil {
            fmt.Println(err)
            return
        }
        fmt.Println("ID:", id, "Name:", name)
    }
}

In this example, we use the database/sql package to interact with a SQLite database. We open a connection to the database, create a table if it doesn’t exist, insert a new record into the table, and then query all records from the table and print them.

Conclusion

Web development with Go offers a powerful and efficient way to build web applications. With the built-in net/http package and third-party libraries like gorilla/mux, you can easily handle HTTP requests, define routes, and serve static files. Additionally, Go’s excellent support for working with databases makes it a great choice for building database-driven web applications. With these tools and techniques, you can build robust and scalable web applications in Go.