**Course Title:** Mastering Go: From Basics to Advanced Development **Section Title:** Working with the Standard Library: File I/O and Networking **Topic:** Introduction to networking in Go: TCP and HTTP As we continue to build on our knowledge of Go programming, we'll now explore the world of networking in Go. Networking is a crucial aspect of modern software development, enabling communication between different systems and services. In this topic, we'll delve into the fundamentals of networking in Go, focusing on TCP and HTTP. ### Overview of Networking in Go Go's standard library provides a robust and efficient networking API, allowing you to write scalable and concurrent networked applications. The `net` package is the foundation of Go's networking capabilities, providing functionality for working with TCP, UDP, IP, and DNS. ### TCP Networking in Go TCP (Transmission Control Protocol) is a connection-oriented protocol that ensures reliable data transfer between systems. In Go, you can use the `net` package to establish and manage TCP connections. Here's an example of a simple TCP server that echoes back messages sent by clients: ```go package main import ( "bufio" "fmt" "net" ) func handleConnection(conn net.Conn) { defer conn.Close() fmt.Println("New connection established") scanner := bufio.NewScanner(conn) for scanner.Scan() { msg := scanner.Text() fmt.Println("Received message:", msg) // Send response back to client conn.Write([]byte(msg + "\n")) } if err := scanner.Err(); err != nil { fmt.Println("Error reading from connection:", err) } } func main() { addr, err := net.ResolveTCPAddr("tcp", ":8080") if err != nil { fmt.Println("Error resolving address:", err) return } listener, err := net.ListenTCP("tcp", addr) if err != nil { fmt.Println("Error listening for connections:", err) return } defer listener.Close() fmt.Println("Listening for connections on port 8080") for { conn, err := listener.Accept() if err != nil { fmt.Println("Error accepting connection:", err) continue } go handleConnection(conn) } } ``` This example demonstrates how to create a TCP server that listens for incoming connections on port 8080. When a connection is established, the `handleConnection` function is called in a separate goroutine to handle the connection. To test this server, you can use the `telnet` command in your terminal: ```bash telnet localhost 8080 ``` Once connected, you can send messages to the server, and it will echo them back. ### HTTP Networking in Go HTTP (Hypertext Transfer Protocol) is a higher-level protocol built on top of TCP. It's used for transferring data between web servers and clients. In Go, you can use the `net/http` package to write HTTP servers and clients. Here's an example of a simple HTTP server that responds to GET requests: ```go package main import ( "fmt" "net/http" ) func helloHandler(w http.ResponseWriter, r *http.Request) { fmt.Fprint(w, "Hello, World!") } func main() { http.HandleFunc("/", helloHandler) http.ListenAndServe(":8080", nil) } ``` This example defines an HTTP handler function `helloHandler` that writes a simple "Hello, World!" message to the response writer. The `http.HandleFunc` function is used to register this handler for the root URL ("/"). To run this server, simply execute the program, and then open your web browser to `http://localhost:8080`. ### Key Concepts and Takeaways * TCP is a connection-oriented protocol that ensures reliable data transfer between systems. * Go's `net` package provides functionality for working with TCP, UDP, IP, and DNS. * HTTP is a higher-level protocol built on top of TCP, used for transferring data between web servers and clients. * Go's `net/http` package provides functionality for writing HTTP servers and clients. ### Practice and Example Use Cases * Write a TCP client that sends a message to a server and prints the response. * Modify the simple HTTP server example to respond to different URLs (e.g., `/hello`, `/goodbye`). * Create an HTTP client that sends a GET request to a web server and prints the response. ### What's Next In the next topic, "Building simple web servers and clients," we'll explore more advanced features of Go's `net/http` package, including how to handle different types of HTTP requests and responses. **Leave a comment below** if you have any questions or need help with the topics covered in this section.