How to implement a TCP server in Go?

Here is a step-by-step guide to implementing a TCP server in Go:

Step 1: Import the necessary packages

To create a TCP server, you need to import the net, bufio and fmt packages.

import (
    "bufio"
    "fmt"
    "net"
)

Step 2: Create a main function

This function will be the entry point to your application.

func main() {
// your code will go here
}

Step 3: Establish a listener on a particular IP and Port

Inside your main function, use net.Listen() to start listening for incoming connections on a particular IP and port.

func main() {
    listen, err := net.Listen("tcp", "localhost:8081")
    if err != nil {
        fmt.Println("Error: ", err.Error())
        return
    }
    // handle connections in the next steps
}

Step 4: Handle incoming connections

After successfully establishing a listener, the next step is to handle incoming connections. You do this by looping infinitely and accepting any incoming call using listener.Accept(). For each connection, you can then spawn a new go routine using the go keyword to handle each connection.

func main() {
    // code from step 3...
    for {
        connection, err := listen.Accept()
        if err != nil {
            fmt.Println("Error: ", err.Error())
            return
        }
        go handleRequest(connection)
    }
}

Step 5: Define the function to handle requests

The next step is to define the handleRequest function. This function will handle each incoming connection. It reads the incoming request, processes it and writes a response back to the client.

func handleRequest(conn net.Conn) {
  //we make a buffer to hold the incoming data.
  buf := make([]byte, 1024)

  // Read the incoming connection into the buffer.
  reqLen, err := conn.Read(buf)
  if err != nil {
    fmt.Println("Error reading:", err.Error())
  }

  // Print the message to the console. 
  fmt.Println("Received data:", string(buf[:reqLen]))

  // Write a response back to the client.
  conn.Write([]byte("Message received."))
  
  // Close the connection when you're done with it.
  conn.Close()
}

Here's the complete server code:

package main

import (
    "bufio"
    "fmt"
    "net"
)

func main() {
    listen, err := net.Listen("tcp", "localhost:8081")
    if err != nil {
        fmt.Println("Error: ", err.Error())
        return
    }
    defer listen.Close()

    for {
        connection, err := listen.Accept()
        if err != nil {
            fmt.Println("Error: ", err.Error())
            return
        }
        go handleRequest(connection)
    }
}

func handleRequest(conn net.Conn) {
    buf := make([]byte, 1024)
    reqLen, err := conn.Read(buf)
    if err != nil {
        fmt.Println("Error reading:", err.Error())
    }
    fmt.Println("Received data:", string(buf[:reqLen]))
    conn.Write([]byte("Message received."))
    conn.Close()
}

To test the server, run it and then use the telnet command to open a TCP connection to the server like this: telnet localhost 8081.

Note: Error handling is minimal in this tutorial code for clarity and readability, in production code make sure to have proper error handling.