📝 Exercise: Create a Basic Web Server in Go

🛠Your Task :

1️⃣ Set up a basic Go web server that listens on port 8080.

2️⃣ Define multiple routes with the following functionalities :

• / (Home Page) → Responds with "Welcome to my Go Web Server!"
• /about → Responds with "This is a basic HTTP server built in Go."
• /api/message → Returns a JSON response :

  
                              {
                                  "message": "Hello from the API!"
                                }
                                
                          

• /greet?name=John → Reads a name parameter from the URL and responds with "Hello, John!"
  • If name is missing, return "Hello, Guest!".

💡 Hints :

• ✅ Usehttp.HandleFunc()to define routes.
• ✅ Usefmt.Fprintf()for simple text responses.
• ✅ For JSON responses, use encoding/jsonand set the Content-Type to "application/json".
• ✅ To read query parameters(name in /greet), user.URL.Query().Get("name").
• ✅ Usehttp.ListenAndServe(":8080", nil)to start the server.

Solution :

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
)

// Message struct for JSON response
type Message struct {
	Message string `json:"message"`
}

func homeHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Welcome to my Go Web Server!")
}

func aboutHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "This is a basic HTTP server built in Go.")
}

func apiMessageHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json") // Set response type to JSON
	response := Message{Message: "Hello from the API!"}
	json.NewEncoder(w).Encode(response) // Encode and send JSON response
}

func greetHandler(w http.ResponseWriter, r *http.Request) {
	name := r.URL.Query().Get("name") // Get 'name' parameter from URL
	if name == "" {
		name = "Guest"
	}
	fmt.Fprintf(w, "Hello, %s!", name)
}

func main() {
	// Define routes
	http.HandleFunc("/", homeHandler)
	http.HandleFunc("/about", aboutHandler)
	http.HandleFunc("/api/message", apiMessageHandler)
	http.HandleFunc("/greet", greetHandler)

	// Start the server on port 8080
	fmt.Println("Server is running on http://localhost:8080")
	http.ListenAndServe(":8080", nil)
}

                

📌 Explanation of the Solution :

• 1️⃣ homeHandler → Handles / route, returns a simple text response.
• 2️⃣ aboutHandler → Handles /about, returns a brief description.
• 3️⃣ apiMessageHandler → Handles /api/message, returns a JSON response.
• 4️⃣ greetHandler → Handles /greet?name=John, extracts the name parameter and responds accordingly.
• 5️⃣ http.ListenAndServe(":8080", nil) → Starts the server on port 8080.

✅ How to Run the Code :

• 1- Save this code in a file, e.g., main.go
• 2- Open a terminal and navigate to the file location.
• 3- Run : go run main.go
• Open a browser and test these URLs :
  • 1-http://localhost:8080/ → Displays "Welcome to my Go Web Server!"
  • 2-http://localhost:8080/about → Displays "This is a basic HTTP server built in Go."
  • 3-http://localhost:8080/api/message → Returns {"message": "Hello from the API!"}
  • 4-http://localhost:8080/greet?name=John → Displays "Hello, John!"
  • 5-http://localhost:8080/greet → Displays "Hello, Guest!"

🚀 Challenge (Optional, for Advanced Practice) :

• 🔹 Add a /static/ route to serve static files (like index.html, style.css).
• 🔹 Implement proper error handling for unknown routes (return a 404 Not Found response).
• 🔹 Log each request to the console using log.Printf().

🚀 Advanced Solution :

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
)

// Message struct for JSON response
type Message struct {
	Message string `json:"message"`
}

// Home route
func homeHandler(w http.ResponseWriter, r *http.Request) {
	logRequest(r)
	fmt.Fprintf(w, "Welcome to my Go Web Server!")
}

// About route
func aboutHandler(w http.ResponseWriter, r *http.Request) {
	logRequest(r)
	fmt.Fprintf(w, "This is a basic HTTP server built in Go.")
}

// API route - JSON response
func apiMessageHandler(w http.ResponseWriter, r *http.Request) {
	logRequest(r)
	w.Header().Set("Content-Type", "application/json")
	response := Message{Message: "Hello from the API!"}
	json.NewEncoder(w).Encode(response)
}

// Greet route - reads a query parameter
func greetHandler(w http.ResponseWriter, r *http.Request) {
	logRequest(r)
	name := r.URL.Query().Get("name")
	if name == "" {
		name = "Guest"
	}
	fmt.Fprintf(w, "Hello, %s!", name)
}

// 404 Not Found handler for unknown routes
func notFoundHandler(w http.ResponseWriter, r *http.Request) {
	logRequest(r)
	w.WriteHeader(http.StatusNotFound)
	fmt.Fprintf(w, "404 Not Found - The requested page does not exist.")
}

// Middleware for logging requests
func logRequest(r *http.Request) {
	log.Printf("[%s] %s %s", r.RemoteAddr, r.Method, r.URL.Path)
}

// Setup logging to a file
func setupLogging() {
	logFile, err := os.OpenFile("server.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
	if err != nil {
		log.Println("Could not open log file, logging to standard output.")
		return
	}
	log.SetOutput(logFile)
}

func main() {
	// Setup logging
	setupLogging()

	// Define routes
	http.HandleFunc("/", homeHandler)
	http.HandleFunc("/about", aboutHandler)
	http.HandleFunc("/api/message", apiMessageHandler)
	http.HandleFunc("/greet", greetHandler)

	// Serve static files (e.g., index.html, style.css)
	fs := http.FileServer(http.Dir("./static"))
	http.Handle("/static/", http.StripPrefix("/static/", fs))

	// Handle unknown routes (404)
	http.HandleFunc("/404", notFoundHandler)
	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/" && r.URL.Path != "/about" && r.URL.Path != "/api/message" && r.URL.Path != "/greet" {
			notFoundHandler(w, r)
		}
	})

	// Start the server
	fmt.Println("Server is running on http://localhost:8080")
	log.Println("Server started on port 8080")
	http.ListenAndServe(":8080", nil)
}

                

📌 Explanation of the Advanced Features :

• 1️⃣ Serving Static Files (/static/) :
  • 1- The server serves static files from the ./static folder.
  • 2- Example: A request to /static/index.html loads ./static/index.html.
  • 3- Implemented using http.FileServer().
• 2️⃣ Handling 404 Not Found :
  • 1- If a request does not match any route, it returns 404 Not Found.
  • 2- Implemented with a custom 404 handler.
• 3️⃣ Logging Requests (log.Printf()) :
  • 1- Logs each request with method, path, and IP.
  • 2- Logs are written to both the console and a file (server.log).
  • 3- Implemented using log.SetOutput().

✅ How to Run the Code :

• 1- Create a static/ folder with some files (e.g., index.html).
• 2- Save the Go file as main.go.
• 3- Run : go run main.go
• 4- Test in the browser :
  • http://localhost:8080/→ Home page
  • http://localhost:8080/about→ About page
  • http://localhost:8080/api/message→ JSON API
  • http://localhost:8080/greet?name=John→ "Hello, John!"
  • http://localhost:8080/static/index.html→ Serves index.html
  • http://localhost:8080/unknown→ Returns 404 Not Found