Building a Web Server in Go

Introduction

Go, often referred to as Golang, is an open-source programming language developed by Google. It’s designed for simplicity, high performance, and concurrent operations. One of Go’s powerful features is that it allows for easy creation of web servers due to its robust standard library. In this tutorial, you’ll learn how to write a basic web server in Go.

Prerequisites

Before you start, ensure you have the following installed:

• Go programming language (1.x or later)
• Text editor or Go IDE of your choice
• Terminal or command-line interface

Creating a Simple Web Server

Step 1: Initialize Your Go Module

Open your terminal and navigate to your workspace directory. Initialize a new module by running:

go mod init your_module_name

Replace your_module_name with a name of your choice.

Step 2: Writing the Server Code

Create a new file named main.go. Add the following code to main.go:

package main

import (
	"fmt"
	"net/http"
)

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

	fmt.Println("Server starting on port 8080...")
	if err := http.ListenAndServe(":8080", nil); err != nil {
		panic(err)
	}
}

In this code, http.HandleFunc tells the Go HTTP package how to handle all incoming web requests to the root URL path /. When a request is received, the anonymous function writes a “Hello, World!” response to the writer w.

The call to http.ListenAndServe launches the server, listening on port 8080. If there is an error starting the server, the program will panic and print the error message.

Step 3: Running Your Server

Execute your server by running this command in your terminal:

go run main.go

If everything is in order, you will see the message Server starting on port 8080... in your terminal.

Now, open a web browser and navigate to http://localhost:8080. You should see “Hello, World!” displayed.

Handling Multiple Routes

To handle different routes, use named functions or separate anonymous functions for each route you want to manage:

http.HandleFunc("/hello", helloHandler)
http.HandleFunc("/goodbye", goodbyeHandler)

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

func goodbyeHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Goodbye!")
}

Adding Middlewares

Middleware allows you to wrap your HTTP handlers with additional functionality:

func loggingMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		log.Printf("Request received: %s", r.URL.Path)
		next.ServeHTTP(w, r)
	})
}

func main() {
	// ...

	http.Handle("/", loggingMiddleware(http.HandlerFunc(mainHandler)))
}

In this example, loggingMiddleware logs the request path every time it’s called before passing control to the mainHandler.

Conclusion

You have successfully written a basic web server in Go. From here, you can expand your server to handle more complicated routes, include middlewares for logging or authentication, and optimize performance for concurrent requests.

Remember, the net/http package is quite extensive and provides more advanced functionalities for production applications, like handling secure connections with HTTPS.

Explore the Go documentation for net/http to learn more, and happy coding!