Creating a Web Socket Server in Go

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setting Up the Project
  4. Creating a Web Socket Server
  5. Handling Incoming Connections
  6. Sending and Receiving Messages

  7. Conclusion

Introduction

In this tutorial, we will learn how to create a Web Socket server in Go. Web Sockets provide a bidirectional communication channel between a client and a server, allowing real-time data transfer. By the end of this tutorial, you will be able to create a simple Web Socket server written in Go and handle incoming connections.

Prerequisites

Before you start this tutorial, it is recommended to have the following knowledge:

  • Basic understanding of Go programming language
  • Familiarity with command-line interface
  • Go development environment set up

You can install the Go programming language from the official Go website (https://golang.org) and set up your development environment accordingly.

Setting Up the Project

To begin, let’s set up a new Go project. Open your terminal and create a new directory for your project:

mkdir websocket-server
cd websocket-server

Next, initialize a new Go module and create a main Go file:

go mod init github.com/your-username/websocket-server
touch main.go

Open main.go in your favorite text editor and let’s start coding our Web Socket server.

Creating a Web Socket Server

First, we need to import the necessary packages from the Go standard library. Open main.go and add the following import statement:

package main

import (
    "log"
    "net/http"

    "github.com/gorilla/websocket"
)

We are importing the log, net/http, and github.com/gorilla/websocket packages. The gorilla/websocket package provides an easy-to-use implementation of Web Sockets in Go.

Next, let’s define a global variable to hold our WebSocket upgrader:

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

The WebSocket upgrader is responsible for upgrading the HTTP connection to a WebSocket connection.

Handling Incoming Connections

Now, let’s create a handler function to handle incoming requests and upgrade them to Web Sockets. Add the following code to main.go:

func wsHandler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println("Failed to upgrade connection:", err)
        return
    }
    defer conn.Close()

    log.Println("New client connected")

    // Handle incoming messages
    for {
        messageType, message, err := conn.ReadMessage()
        if err != nil {
            log.Println("Error reading message:", err)
            break
        }

        log.Printf("Received message: %s", message)

        // Echo the message back to the client
        err = conn.WriteMessage(messageType, message)
        if err != nil {
            log.Println("Error writing message:", err)
            break
        }
    }
}

The wsHandler function takes an http.ResponseWriter and an http.Request as parameters. It upgrades the HTTP connection to a WebSocket connection using the upgrader.Upgrade method.

Inside the handler, we log when a new client connects. We then enter a loop to handle incoming messages from the client. Any message received is echoed back to the client using the conn.WriteMessage method. If an error occurs during reading or writing messages, we log the error and break out of the loop.

Sending and Receiving Messages

To complete our Web Socket server, we need to start the server and handle incoming connections. Add the following code to the main function:

func main() {
    http.HandleFunc("/ws", wsHandler)

    log.Println("Starting Web Socket server on http://localhost:8000/ws")
    if err := http.ListenAndServe(":8000", nil); err != nil {
        log.Fatal("Failed to start server:", err)
    }
}

In the main function, we register our wsHandler function to handle requests made to the /ws endpoint. We then start the server on http://localhost:8000/ws by calling http.ListenAndServe.

That’s it! You have successfully created a Web Socket server in Go. Save the file and let’s test it.

Open your terminal and navigate to the project directory. Run the following command to start the server:

go run main.go

The server is now running and waiting for incoming connections. To test it, you can use a browser supporting Web Sockets or a Web Socket client library.

Conclusion

In this tutorial, we have learned how to create a Web Socket server in Go. We covered the basics of setting up a project, handling incoming connections, and sending/receiving messages using the Gorilla Web Socket library.

By understanding the concepts presented in this tutorial, you can build powerful real-time applications that require bidirectional communication between clients and servers. Experiment with different use cases and explore additional features provided by the Gorilla Web Socket library.

Remember to refer to the official documentation of Go and Gorilla Web Socket for more advanced usage and detailed explanations.

Now that you have the knowledge and skills to create a Web Socket server in Go, have fun building your own real-time applications!

Published:

Related Articles