Software Careers

Introduction to WebSockets

In the world of web development, real-time communication between clients and servers has become increasingly important. Whether it's for chat applications, live updates, or multiplayer gaming, WebSockets provide an efficient solution for full-duplex communication over a single TCP connection. Unlike HTTP, which requires a request-response cycle, WebSockets enable continuous data exchange without the overhead of repeated requests.

What Are WebSockets?

WebSockets are a protocol that allows for persistent, bi-directional communication between a client (typically a web browser) and a server. Once a WebSocket connection is established, the server can push updates to the client instantly, and the client can send messages to the server without needing to re-establish a connection.

Server-Side WebSocket Implementations

JavaScript (Node.js)

JavaScript, with its non-blocking, event-driven nature, is particularly well-suited for WebSocket servers. The ws library is a popular choice for creating WebSocket servers in Node.js.

const WebSocket = require('ws');

const server = new WebSocket.Server({ port: 8080 });

server.on('connection', socket => {
  console.log('Client connected');

  socket.on('message', message => {
    console.log(`Received: ${message}`);
    socket.send('Message received');
  });

  socket.on('close', () => {
    console.log('Client disconnected');
  });
});

console.log('WebSocket server is running on ws://localhost:8080');

JavaScript example of a WebSocket server using the ws library.

Python

Python is versatile and offers several libraries for WebSocket communication, with websockets being one of the most commonly used.

import asyncio
import websockets

async def handler(websocket, path):
    async for message in websocket:
        print(f"Received: {message}")
        await websocket.send("Message received")

start_server = websockets.serve(handler, "localhost", 8080)

asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()

Python example of a WebSocket server using the websockets library.

Java

Java provides built-in support for WebSockets through the javax.websocket package, making it easy to integrate into Java-based applications.

import javax.websocket.OnMessage;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;

@ServerEndpoint("/websocket")
public class WebSocketServer {

    @OnMessage
    public String onMessage(String message, Session session) {
        System.out.println("Received: " + message);
        return "Message received";
    }
}

Java example of a WebSocket server using the javax.websocket package.

Go

Go (Golang) is a language designed with concurrency in mind, making it ideal for WebSocket servers. The gorilla/websocket package is a popular library for this purpose.

package main

import (
    "fmt"
    "net/http"
    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    CheckOrigin: func(r *http.Request) bool { return true },
}

func handleWebSocket(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer conn.Close()

    for {
        _, msg, err := conn.ReadMessage()
        if err != nil {
            fmt.Println(err)
            break
        }
        fmt.Printf("Received: %s\n", msg)
        if err := conn.WriteMessage(websocket.TextMessage, []byte("Message received")); err != nil {
            fmt.Println(err)
            break
        }
    }
}

func main() {
    http.HandleFunc("/ws", handleWebSocket)
    fmt.Println("WebSocket server is running on ws://localhost:8080/ws")
    http.ListenAndServe(":8080", nil)
}

Go example of a WebSocket server using the gorilla/websocket package.

C#

C# and the .NET framework offer WebSocket support via the System.Net.WebSockets namespace, making it straightforward to implement WebSockets in a .NET application.

using System;
using System.Net.WebSockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var server = new WebSocketServer();
        await server.StartAsync("http://localhost:8080/ws");
    }
}

class WebSocketServer
{
    public async Task StartAsync(string uri)
    {
        var httpListener = new HttpListener();
        httpListener.Prefixes.Add(uri);
        httpListener.Start();

        Console.WriteLine("WebSocket server is running...");

        while (true)
        {
            var context = await httpListener.GetContextAsync();
            if (context.Request.IsWebSocketRequest)
            {
                var wsContext = await context.AcceptWebSocketAsync(null);
                await HandleConnectionAsync(wsContext.WebSocket);
            }
            else
            {
                context.Response.StatusCode = 400;
                context.Response.Close();
            }
        }
    }

    private async Task HandleConnectionAsync(WebSocket socket)
    {
        var buffer = new byte[1024];

        while (socket.State == WebSocketState.Open)
        {
            var result = await socket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
            var message = Encoding.UTF8.GetString(buffer, 0, result.Count);
            Console.WriteLine($"Received: {message}");

            var response = Encoding.UTF8.GetBytes("Message received");
            await socket.SendAsync(new ArraySegment<byte>(response), WebSocketMessageType.Text, true, CancellationToken.None);
        }
    }
}

C# example of a WebSocket server using the System.Net.WebSockets namespace.

Ruby

Ruby, known for its simplicity and elegance, can handle WebSocket connections using the faye-websocket gem.

require 'faye/websocket'
require 'eventmachine'

EM.run do
  EM::WebSocket.run(host: '0.0.0.0', port: 8080) do |ws|
    ws.onopen { puts 'Client connected' }

    ws.onmessage do |msg|
      puts "Received: #{msg}"
      ws.send 'Message received'
    end

    ws.onclose { puts 'Client disconnected' }
  end
end

Ruby example of a WebSocket server using the faye-websocket gem.

Client-Side WebSocket Implementation

Now that we’ve covered server-side implementations, let's look at how to create a client-side WebSocket connection in JavaScript. This client-side code can interact with any of the server-side implementations provided above.

const socket = new WebSocket('ws://localhost:8080/ws');

socket.addEventListener('open', function (event) {
    console.log('Connected to the server');
    socket.send('Hello, Server!');
});

socket.addEventListener('message', function (event) {
    console.log('Message from server:', event.data);
});

socket.addEventListener('close', function (event) {
    console.log('Disconnected from the server');
});

JavaScript example of a WebSocket client.

Conclusion

WebSockets are a powerful tool for enabling real-time, bidirectional communication between clients and servers. Whether you’re building a chat application, a live update system, or any other real-time feature, WebSockets provide a robust solution that can be implemented across a wide range of programming languages.

This blog has walked you through the basics of setting up a WebSocket server in JavaScript (Node.js), Python, Java, Go, C#, and Ruby, along with a simple client-side implementation in JavaScript. Armed with this knowledge, you can start integrating WebSockets into your own projects, enhancing user experiences with real-time communication.

WebSockets: A Comprehensive Guide to Real-Time Communication Across Different Languages