Golang http.HandleFunc Function

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

The http.HandleFunc function in Golang is part of the net/http package and is used to register a handler function for a specific HTTP request path. This function is essential for setting up routing in a web server, allowing you to easily associate a path with a function that will handle incoming HTTP requests to that path.

Introduction
http.HandleFunc Function Syntax
Examples
- Basic Usage
- Handling Multiple Paths
- Using Query Parameters
Real-World Use Case
Conclusion

Introduction

The http.HandleFunc function simplifies the process of registering a handler for a specific path by allowing you to use a function directly. This is especially useful when building web servers, as it allows for quick and easy routing of HTTP requests to the appropriate handler functions.

http.HandleFunc Function Syntax

The syntax for the http.HandleFunc function is as follows:

func HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request))

Parameters:

pattern: A string representing the path pattern to match. It can be a specific path like /hello or a pattern like /static/.
handler: A function that takes an http.ResponseWriter and an *http.Request as arguments. This function handles the HTTP request and generates a response.

Returns:

The function does not return any value.

Examples

Basic Usage

This example demonstrates how to use the http.HandleFunc function to register a handler function for a specific path.

Example

package main

import (
	"fmt"
	"net/http"
)

func main() {
	// Register a handler function for the "/hello" path
	http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "Hello, Golang!")
	})

	// Start the server on port 8080
	http.ListenAndServe(":8080", nil)
}

Explanation:

The code sets up a web server that listens on port 8080.
The /hello path is associated with a handler function that responds with "Hello, Golang!" when accessed.

Handling Multiple Paths

This example shows how to handle multiple paths using http.HandleFunc.

Example

package main

import (
	"fmt"
	"net/http"
)

func main() {
	// Register a handler function for the "/hello" path
	http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "Hello, Golang!")
	})

	// Register a handler function for the "/goodbye" path
	http.HandleFunc("/goodbye", func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "Goodbye, Golang!")
	})

	// Start the server on port 8080
	http.ListenAndServe(":8080", nil)
}

Explanation:

The code registers two handler functions: one for the /hello path and another for the /goodbye path.
Each path has its own handler function that sends a different response.

Using Query Parameters

This example demonstrates how to access query parameters in a request handled by a function registered with http.HandleFunc.

Example

package main

import (
	"fmt"
	"net/http"
)

func main() {
	// Register a handler function for the "/greet" path
	http.HandleFunc("/greet", func(w http.ResponseWriter, r *http.Request) {
		// Get the "name" query parameter
		name := r.URL.Query().Get("name")
		if name == "" {
			name = "Golang"
		}
		fmt.Fprintf(w, "Hello, %s!\n", name)
	})

	// Start the server on port 8080
	http.ListenAndServe(":8080", nil)
}

Explanation:

The code sets up a handler for the /greet path that reads the name query parameter from the URL and includes it in the response.
If the name parameter is not provided, it defaults to "Golang."

Example Request:

http://localhost:8080/greet?name=John

Output:

Hello, John!

Real-World Use Case

Simple Web API

In real-world applications, http.HandleFunc can be used to create simple web APIs that respond to different paths and query parameters.

Example: Creating a Simple Web API

package main

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

// Message is a simple struct for JSON response
type Message struct {
	Greeting string `json:"greeting"`
}

func main() {
	// Register a handler function for the "/api/greet" path
	http.HandleFunc("/api/greet", func(w http.ResponseWriter, r *http.Request) {
		// Get the "name" query parameter
		name := r.URL.Query().Get("name")
		if name == "" {
			name = "Golang"
		}

		// Create a message
		msg := Message{Greeting: "Hello, " + name + "!"}

		// Set content type to JSON and send the response
		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(msg)
	})

	// Start the server on port 8080
	http.ListenAndServe(":8080", nil)
}

Explanation:

The code creates a simple API endpoint /api/greet that responds with a JSON message containing a greeting.
The name query parameter is used to customize the greeting.

Example Request:

http://localhost:8080/api/greet?name=John

Output:

{
  "greeting": "Hello, John!"
}

Conclusion

The http.HandleFunc function in Go is a powerful and convenient tool for setting up HTTP routes and handlers in a web application. By associating paths with specific functions, you can easily build a web server that responds to various HTTP requests. Whether you're creating simple web pages, handling query parameters, or building APIs, http.HandleFunc provides a straightforward and efficient way to manage HTTP routes and their corresponding actions.

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Spring Boot + RabbitMQ Course - The Practical Guide

Java Guides

Search This Blog