Building a Chat Application in Go

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setup and Installation
  4. Creating a Chat Server
  5. Building a Chat Client

  6. Conclusion

Introduction

In this tutorial, we will learn how to build a Chat Application in Go. We will create a simple chat server that allows multiple clients to connect and exchange messages in real-time. By the end of this tutorial, you will have a basic understanding of networking concepts, concurrency in Go, and how to build a chat application using the Go programming language.

Prerequisites

To follow this tutorial, you need to have a basic understanding of the Go programming language. Familiarity with networking concepts, such as TCP/IP, clients, and servers, will also be helpful. Additionally, make sure you have Go installed on your system. You can download and install Go from the official Go website (https://golang.org/dl/).

Setup and Installation

Before we begin, let’s set up our project directory and install any necessary dependencies. Open your terminal and follow these steps:

  1. Create a new directory for your project: mkdir chatapp
  2. Change into the project directory: cd chatapp

  3. Initialize a new Go module: go mod init github.com/your-username/chatapp

  4. Install a WebSocket library for Go: go get github.com/gorilla/websocket

    With these steps, we have created a new project directory and installed the WebSocket library gorilla/websocket, which we will use for building our chat application.

Creating a Chat Server

  1. Open a new file server.go in your favorite text editor.

  2. Add the following code to import the necessary packages:

     package main
    
 import (
 	"log"
 	"net/http"
 	"github.com/gorilla/websocket"
 )

  3. Next, define a ChatServer struct that will keep track of the connected clients and handle incoming messages:

     type ChatServer struct {
 	clients map[*websocket.Conn]bool
 	broadcast chan []byte
 }

  4. Implement methods for ChatServer to handle client connections, disconnections, and message broadcasting:

     func (s *ChatServer) handleConnections(w http.ResponseWriter, r *http.Request) {
 	// Upgrade HTTP connection to WebSocket protocol
 	upgrader := websocket.Upgrader{}
 	conn, err := upgrader.Upgrade(w, r, nil)
 	if err != nil {
 		log.Fatal(err)
 	}
 	// Register new client
 	s.clients[conn] = true
 }
    
 func (s *ChatServer) handleDisconnections(conn *websocket.Conn) {
 	// Remove client from the connected clients map
 	delete(s.clients, conn)
 	// Close the connection
 	conn.Close()
 }
    
 func (s *ChatServer) handleMessages() {
 	for {
 		// Read message from client
 		_, msg, err := conn.ReadMessage()
 		if err != nil {
 			s.handleDisconnections(conn)
 			break
 		}
 		// Broadcast message to all connected clients
 		for client := range s.clients {
 			err := client.WriteMessage(websocket.TextMessage, msg)
 			if err != nil {
 				log.Printf("Error: %v", err)
 				s.handleDisconnections(client)
 			}
 		}
 	}
 }

  5. Create a main function to start the chat server:

     func main() {
 	// Initialize chat server
 	server := ChatServer{
 		clients:   make(map[*websocket.Conn]bool),
 		broadcast: make(chan []byte),
 	}
    
 	// Configure HTTP server
 	http.HandleFunc("/ws", server.handleConnections)
 	go server.handleMessages()
    
 	// Start server
 	log.Println("Chat Server started on localhost:8000")
 	log.Fatal(http.ListenAndServe(":8000", nil))
 }

  6. Save your changes and run the server using the following command: go run server.go

    Congratulations! You have successfully created a chat server that listens for client connections and broadcasts messages to all connected clients.

Building a Chat Client

Now that we have our chat server up and running, let’s build a simple command-line chat client.

  1. Open a new file client.go in your text editor.

  2. Add the following code for the client:

     package main
    
 import (
 	"fmt"
 	"log"
 	"net/url"
 	"os"
 	"os/signal"
 	"github.com/gorilla/websocket"
 )
    
 func main() {
 	// Set WebSocket URL
 	u := url.URL{Scheme: "ws", Host: "localhost:8000", Path: "/ws"}
 	log.Printf("Connecting to %s", u.String())
    
 	// Connect to WebSocket server
 	conn, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
 	if err != nil {
 		log.Fatal(err)
 	}
 	defer conn.Close()
    
 	// Handle received messages in separate goroutine
 	go func() {
 		for {
 			_, msg, err := conn.ReadMessage()
 			if err != nil {
 				log.Println("Connection closed by server")
 				return
 			}
 			fmt.Println("Received message:", string(msg))
 		}
 	}()
    
 	// Read user input and send messages
 	interrupt := make(chan os.Signal, 1)
 	signal.Notify(interrupt, os.Interrupt)
    
 	for {
 		select {
 		case <-interrupt:
 			log.Println("Interrupt signal received, closing connection...")
 			err := conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
 			if err != nil {
 				log.Println("Error:", err)
 			} else {
 				return
 			}
 		default:
 			var msg string
 			fmt.Print("Enter message: ")
 			fmt.Scanln(&msg)
    
 			err := conn.WriteMessage(websocket.TextMessage, []byte(msg))
 			if err != nil {
 				log.Println("Error:", err)
 				return
 			}
 		}
 	}
 }

  3. Save your changes and run the client using the following command: go run client.go

    Now you have a chat client that connects to the chat server and allows you to send and receive messages. Open multiple terminals and run the client to simulate multiple users chatting with each other.

Conclusion

In this tutorial, we have learned how to build a simple chat application in Go. We created a chat server that handles client connections and message broadcasting using the gorilla/websocket library. Additionally, we built a chat client that connects to the server and allows users to send and receive messages.

Go provides excellent support for building concurrent and networked applications, making it a great choice for developing chat applications or any real-time communication systems. You can further customize and enhance the chat application by adding features such as user authentication, message logging, or even integrating it with a web interface.

I hope this tutorial has provided you with a good starting point for building your own chat applications in Go. Happy coding!

Published:

Related Articles