WebSockets tutorial: How to go real-time with Node and React
Tags: react, javascript, node
Published: 2019-07-08 20:01:31

---
title: WebSockets tutorial: How to go real-time with Node and React
published: true
tags: react,javascript,nodejs
canonical_url: https://blog.logrocket.com/websockets-tutorial-how-to-go-real-time-with-node-and-react-8e4693fbf843
---

![](https://cdn-images-1.medium.com/max/1024/1*qu8smzbhsJibnm1jgArhbg.jpeg)

The web has traveled a long way to support full-duplex (or two-way) communication between a client and server. This is the prime intention of the WebSocket protocol: to provide persistent real-time communication between the client and the server over a single TCP socket connection.

The WebSocket protocol has only two agendas : 1) to open up a handshake, and 2) to help the data transfer. Once the server and client both have their handshakes in, they can send data to each other with less overhead at will.

WebSocket communication takes place over a single TCP socket using either WS (port 80) or WSS (port 443) protocol. Almost every browser except Opera Mini provides admirable support for WebSockets at the time of writing, as per [Can I Use](https://caniuse.com/#feat=websockets).

[![](https://cdn-images-1.medium.com/max/1024/1*wV7zU6J05BL3bphzMlB2rA.png)](https://logrocket.com/signup/)

### The story so far

Historically, creating web apps that needed real-time data (like gaming or chat apps) required an [abuse of HTTP protocol](https://tools.ietf.org/html/rfc6202) to establish bidirectional data transfer. There were multiple methods used to achieve real-time capabilities, but none of them were as efficient as WebSockets. HTTP polling, HTTP streaming, Comet, SSE — they all had their own drawbacks.

#### HTTP polling

The very first attempt to solve the problem was by polling the server at regular intervals. The HTTP long polling lifecycle is as follows:

1. The client sends out a request and keeps waiting for a response.
2. The server defers its response until there’s a change, update, or timeout. The request stayed “hanging” until the server had something to return to the client.
3. When there’s some change or update on the server end, it sends a response back to the client.
4. The client sends a new long poll request to listen to the next set of changes.

There were a lot of loopholes in long polling — header overhead, latency, timeouts, caching, and so on.

#### HTTP streaming

This mechanism saved the pain of network latency because the initial request is kept open indefinitely. The request is never terminated, even after the server pushes the data. The first three lifecycle methods of HTTP streaming are the same in HTTP polling.

When the response is sent back to the client, however, the request is never terminated; the server keeps the connection open and sends new updates whenever there’s a change.

#### **Server-sent events (SSE)**

With SSE, the server pushes data to the client. A chat or gaming application cannot completely rely on SSE. The perfect use case for SSE would be, e.g., the Facebook News Feed: whenever new posts comes in, the server pushes them to the timeline. SSE is sent over traditional HTTP and has restrictions on the number of open connections.

These methods were not just inefficient, the code that went into them also made developers tired.

### Why WebSocket is the prince that was promised

WebSockets are designed to supersede the existing bidirectional communication technologies. The existing methods described above are neither reliable nor efficient when it comes to full-duplex real-time communications.

WebSockets are similar to SSE but also triumph in taking messages back from the client to the server. Connection restrictions are no longer an issue since data is served over a single TCP socket connection.

### Practical tutorial

As mentioned in the introduction, the WebSocket protocol has only two agendas. Let’s see how WebSockets fulfills those agendas. To do that, I’m going to spin off a Node.js server and connect it to a client built with React.js.

### **Agenda 1: WebSocket establishes a handshake between server and client**

#### **Creating a handshake at the server level**

We can make use of a single port to spin off the HTTP server and the WebSocket server. The gist below shows the creation of a simple HTTP server. Once it is created, we tie the WebSocket server to the HTTP port:

```jsx
const webSocketsServerPort = 8000;
const webSocketServer = require('websocket').server;
const http = require('http');
// Spinning the http server and the websocket server.
const server = http.createServer();
server.listen(webSocketsServerPort);
const wsServer = new webSocketServer({
  httpServer: server
});
```

Once the WebSocket server is created, we need to accept the handshake on receiving the request from the client. I maintain all the connected clients as an object in my code with a unique user-id on receiving their request from the browser.

```jsx
// I'm maintaining all active connections in this object
const clients = {};

// This code generates unique userid for everyuser.
const getUniqueID = () => {
  const s4 = () => Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1);
  return s4() + s4() + '-' + s4();
};

wsServer.on('request', function(request) {
  var userID = getUniqueID();
  console.log((new Date()) + ' Recieved a new connection from origin ' + request.origin + '.');
  // You can rewrite this part of the code to accept only the requests from allowed origin
  const connection = request.accept(null, request.origin);
  clients[userID] = connection;
  console.log('connected: ' + userID + ' in ' + Object.getOwnPropertyNames(clients))
});
```

**_So, what happens when the connection is accepted?_**

While sending the regular HTTP request to establish a connection, in the request headers, the client sends \*Sec-WebSocket-Key\*. The server encodes and hashes this value and adds a predefined GUID. It echoes the generated value in the \*Sec-WebSocket-Accept\* in the server-sent handshake.

Once the request is accepted in the server (after necessary validations in production), the handshake is fulfilled with status code 101. If you see anything other than status code 101 in the browser, the WebSocket upgrade has failed, and the normal HTTP semantics will be followed.

The \*Sec-WebSocket-Accept\* header field indicates whether the server is willing to accept the connection or not. Also, if the response lacks an \*Upgrade\* header field, or the \*Upgrade\* does not equal websocket, it means the WebSocket connection has failed.

The successful server handshake looks like this:

```jsx
HTTP GET ws://127.0.0.1:8000/ 101 Switching Protocols
Connection: Upgrade
Sec-WebSocket-Accept: Nn/XHq0wK1oO5RTtriEWwR4F7Zw=
Upgrade: websocket
```

#### Creating a handshake at the client level

At the client level, I’m using the same WebSocket package we are using in the server to establish the connection with the server (the WebSocket API in Web IDL is being standardized by the W3C). As soon as the request is accepted by the server, we will see WebSocket Client Connected on the browser console.

Here’s the initial scaffold to create the connection to the server:

```jsx
import React, { Component } from 'react';
import { w3cwebsocket as W3CWebSocket } from "websocket";

const client = new W3CWebSocket('ws://127.0.0.1:8000');

class App extends Component {
  componentWillMount() {
    client.onopen = () => {
      console.log('WebSocket Client Connected');
    };
    client.onmessage = (message) => {
      console.log(message);
    };
  }
  
  render() {
    return (
      <div>
        Practical Intro To WebSockets.
      </div>
    );
  }
}

export default App;
```

The following headers are sent by the client to establish the handshake:

```jsx
HTTP GET ws://127.0.0.1:8000/ 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: vISxbQhM64Vzcr/CD7WHnw==
Origin: http://localhost:3000
Sec-WebSocket-Version: 13
```

Now that the client and server are connected with mutual handshakes, the WebSocket connection can transmit messages as it receives them, thereby fulfilling the second agenda of WebSocket protocol.

### Agenda 2: Real-time message transmission

![](https://cdn-images-1.medium.com/max/1024/1*Nzx8FJa3bTZSri9BED3I1g.gif)<figcaption>Real-time streaming of content modification.</figcaption>

I’m going to code a basic real-time document editor where users can join together and edit a document. I’m tracking two events:

1. **User activities:** Every time a user joins or leaves, I broadcast the message to all the other connected clients.
2. **Content changes:** Every time content in the editor is changed, it is broadcast to all the other connected clients.

The protocol allows us to send and receive messages as binary data or UTF-8 (N.B., transmitting and converting UTF-8 has less overhead).

Understanding and implementing WebSockets is very easy as long as we have a good understanding of the socket events: onopen, onclose, and onmessage. The terminologies are the same on both the client and the server side.

#### **Sending and listening to messages on the client side**

From the client, when a new user joins in or when content changes, we trigger a message to the server using client.send to take the new information to the server.

```jsx
const webSocketsServerPort = 8000;
const webSocketServer = require('websocket').server;
const http = require('http');
// Spinning the http server and the websocket server.
const server = http.createServer();
server.listen(webSocketsServerPort);
const wsServer = new webSocketServer({
  httpServer: server
});
```
*The events we track: a user joining and content changing.*

And listening to messages from the server are pretty simple:

```jsx
componentWillMount() {
  client.onopen = () => {
   console.log('WebSocket Client Connected');
  };
  client.onmessage = (message) => {
    const dataFromServer = JSON.parse(message.data);
    const stateToChange = {};
    if (dataFromServer.type === "userevent") {
      stateToChange.currentUsers = Object.values(dataFromServer.data.users);
    } else if (dataFromServer.type === "contentchange") {
      stateToChange.text = dataFromServer.data.editorContent || contentDefaultMessage;
    }
    stateToChange.userActivity = dataFromServer.data.userActivity;
    this.setState({
      ...stateToChange
    });
  };
}
```

#### Sending and listening to messages on the server side

In the server, we simply have to catch the incoming message and broadcast it to all the clients connected to the WebSocket. And this is one of the differences between the infamous Socket.IO and WebSocket: we need to manually send the message to all clients when we use WebSockets. Socket.IO is a full-fledged library, so it handles that on its own.

```jsx
// I'm maintaining all active connections in this object
const clients = {};

// This code generates unique userid for everyuser.
const getUniqueID = () => {
  const s4 = () => Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1);
  return s4() + s4() + '-' + s4();
};

wsServer.on('request', function(request) {
  var userID = getUniqueID();
  console.log((new Date()) + ' Recieved a new connection from origin ' + request.origin + '.');
  // You can rewrite this part of the code to accept only the requests from allowed origin
  const connection = request.accept(null, request.origin);
  clients[userID] = connection;
  console.log('connected: ' + userID + ' in ' + Object.getOwnPropertyNames(clients))
});
```
*Broadcasting the message to all connected clients.*

![](https://cdn-images-1.medium.com/max/1024/1*MqOjfmnuia8J3MGXsjF_vA.gif)

#### What happens when the browser is closed?

In that case, the WebSocket invokes the close event, which allows us to write the logic to terminate the current user’s connection. In my code, I broadcast a message to the remaining users when a user leaves the document:

```jsx
connection.on('close', function(connection) {
    console.log((new Date()) + " Peer " + userID + " disconnected.");
    const json = { type: typesDef.USER_EVENT };
    userActivity.push(`${users[userID].username} left the document`);
    json.data = { users, userActivity };
    delete clients[userID];
    delete users[userID];
    sendMessage(JSON.stringify(json));
  });
```

The source code for this application is in my [repo](https://github.com/AvanthikaMeenakshi/node-websockets) on GitHub.

### Conclusion

WebSockets are one of the most interesting and convenient ways to achieve real-time capabilities in an application. It gives us a lot of flexibility to leverage full-duplex communications. I’d strongly suggest working with WebSockets before trying out Socket.IO and other available libraries.

Happy coding! :)
* * *
### Plug: [LogRocket](https://logrocket.com/signup/), a DVR for web apps

[![](https://cdn-images-1.medium.com/max/1024/1*s_rMyo6NbrAsP-XtvBaXFg.png)](https://logrocket.com/signup/)<figcaption><a href="https://logrocket.com/signup/">https://logrocket.com/signup/</a></figcaption>

[LogRocket](https://logrocket.com/signup/) is a frontend logging tool that lets you replay problems as if they happened in your own browser. Instead of guessing why errors happen, or asking users for screenshots and log dumps, LogRocket lets you replay the session to quickly understand what went wrong. It works perfectly with any app, regardless of framework, and has plugins to log additional context from Redux, Vuex, and @ngrx/store.

In addition to logging Redux actions and state, LogRocket records console logs, JavaScript errors, stacktraces, network requests/responses with headers + bodies, browser metadata, and custom logs. It also instruments the DOM to record the HTML and CSS on the page, recreating pixel-perfect videos of even the most complex single-page apps.

[Try it for free](https://logrocket.com/signup/).
* * *
The post [WebSockets tutorial: How to go real-time with Node and React](https://blog.logrocket.com/websockets-tutorial-how-to-go-real-time-with-node-and-react-8e4693fbf843/) appeared first on [LogRocket Blog](https://blog.logrocket.com).