Why Switch from WebSocket to MQTT for Real‑Time Messaging?

Fundamental Differences Between WebSocket and MQTT

WebSocket is a transport‑layer extension that upgrades an HTTP handshake to a long‑lived TCP channel, providing only a bidirectional data stream without any message semantics. All features such as subscription, retransmission, offline storage, and load balancing must be implemented by the application.

MQTT is an application‑layer publish/subscribe protocol designed for low‑bandwidth, weak‑network, and massive‑connection scenarios. It natively includes topic subscription, QoS levels, offline messages, retained messages, heartbeat, and session persistence.

Connection Capacity and Weak‑Network Adaptation

Native WebSocket servers encounter memory and thread limits at tens of thousands of connections. MQTT brokers such as EMQX, built on Erlang's lightweight process model, support millions of concurrent connections with minimal memory usage.

In weak‑network conditions, WebSocket drops undelivered messages on disconnection, requiring manual caching. MQTT’s QoS 1/2 guarantees message persistence and automatic redelivery after reconnection.

Cluster Scaling and Message Synchronization

WebSocket clusters suffer from “connection sharding”: a client connected to node A cannot receive messages published on node B without additional Redis pub/sub or message‑queue middleware, increasing architectural complexity and risking duplicate or lost messages.

MQTT brokers embed cluster‑wide distribution; a message published to a topic is automatically synchronized to all nodes, ensuring delivery regardless of which node a client is attached to, with zero extra development.

Feature Comparison by Use Case

Offline Message Push – WebSocket requires custom Redis or DB caching; MQTT stores offline messages in the session and pushes them on reconnection.

One‑to‑One and Group Chat – WebSocket needs manual user‑connection mapping; MQTT uses topics such as user/{userId}/private and group/{groupId} for automatic routing.

Reliable Delivery – WebSocket has no retransmission; MQTT offers QoS 0/1/2 to control at‑most‑once, at‑least‑once, or exactly‑once delivery.

Device Offline Notification – WebSocket requires heartbeat detection; MQTT provides built‑in Last‑Will messages.

Bandwidth Overhead – WebSocket payloads are custom and often verbose; MQTT uses compact binary frames with a tiny header, saving bandwidth on mobile and IoT devices.

Core MQTT Capabilities

Hierarchical Topic Model

MQTT topics support single‑level (+) and multi‑level (#) wildcards, enabling flexible subscription patterns:

Private messages: msg/user/{userId} Group chat: msg/group/{groupId} System broadcast: msg/system/all Category notifications: msg/order/{userId},

msg/notice/{userId}

QoS Levels

QoS 0 – At most once, suitable for non‑critical notifications.

QoS 1 – At least once, may duplicate, ideal for chat messages and alerts.

QoS 2 – Exactly once, handshake‑based, used for orders, payments, or critical device reports.

Session Persistence & Offline Cache

Setting cleanSession=false makes the broker retain subscriptions and undelivered messages. When a client reconnects, all cached messages are automatically delivered.

Last‑Will Messages

Clients can predefine a will topic and payload; if the connection is lost without a heartbeat, the broker publishes the will message, allowing the server to detect abnormal disconnections.

Heartbeat Keep‑Alive

The client specifies a keep‑alive interval; the broker marks the session offline after the interval expires, providing a standard, low‑overhead connection health check.

Quick Local Deployment of EMQX

One‑Click Docker Start

docker run -d --name emqx -p 1883:1883 -p 8083:8083 -p 18083:18083 emqx/emqx:5.3.0

Port mapping:

1883 – Standard MQTT TCP port.

8083 – MQTT over WebSocket (for front‑end connections).

18083 – Management dashboard (default admin/public).

Basic Permission Configuration

Log into the dashboard, create authentication accounts, and disable anonymous access for production environments.

SpringBoot Integration (Backend Production Ready)

Maven Dependency

<dependency>
  <groupId>org.eclipse.paho</groupId>
  <artifactId>org.eclipse.paho.client.mqttv3</artifactId>
  <version>1.2.5</version>
</dependency>

application.yml Configuration

mqtt:
  broker: tcp://127.0.0.1:1883
  username: admin
  password: public
  client-id: server-producer
  clean-session: false
  keep-alive: 30
  default-qos: 1

MQTT Client Configuration Class

import org.eclipse.paho.client.mqttv3.*;
import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MqttConfig {
    @Value("${mqtt.broker}") private String broker;
    @Value("${mqtt.username}") private String username;
    @Value("${mqtt.password}") private String password;
    @Value("${mqtt.client-id}") private String clientId;
    @Value("${mqtt.clean-session}") private boolean cleanSession;
    @Value("${mqtt.keep-alive}") private int keepAlive;

    @Bean(destroyMethod = "disconnect")
    public MqttClient mqttClient() throws MqttException {
        MemoryPersistence persistence = new MemoryPersistence();
        MqttConnectOptions options = new MqttConnectOptions();
        options.setUserName(username);
        options.setPassword(password.toCharArray());
        options.setCleanSession(cleanSession);
        options.setKeepAliveInterval(keepAlive);
        options.setAutomaticReconnect(true);
        MqttClient client = new MqttClient(broker, clientId, persistence);
        client.setCallback(new MqttMessageCallback());
        client.connect(options);
        return client;
    }
}

Message Callback Handler

import org.eclipse.paho.client.mqttv3.IMqttDeliveryToken;
import org.eclipse.paho.client.mqttv3.MqttCallback;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import java.nio.charset.StandardCharsets;

public class MqttMessageCallback implements MqttCallback {
    @Override
    public void connectionLost(Throwable cause) {
        System.err.println("MQTT connection lost, reconnecting: " + cause.getMessage());
    }
    @Override
    public void messageArrived(String topic, MqttMessage message) throws Exception {
        String payload = new String(message.getPayload(), StandardCharsets.UTF_8);
        System.out.println("Received topic [" + topic + "] message: " + payload);
        // Business logic placeholder
    }
    @Override
    public void deliveryComplete(IMqttDeliveryToken token) {}
}

Utility Class for Publishing & Subscribing

import org.eclipse.paho.client.mqttv3.MqttClient;
import org.eclipse.paho.client.mqttv3.MqttException;
import org.eclipse.paho.client.mqttv3.MqttMessage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MqttUtil {
    @Autowired private MqttClient mqttClient;

    public void publish(String topic, String content, int qos) throws MqttException {
        MqttMessage message = new MqttMessage();
        message.setPayload(content.getBytes());
        message.setQos(qos);
        mqttClient.publish(topic, message);
    }

    public void subscribe(String topic, int qos) throws MqttException {
        mqttClient.subscribe(topic, qos);
    }
}

Controller Example

import org.eclipse.paho.client.mqttv3.MqttException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MsgController {
    @Autowired private MqttUtil mqttUtil;

    @GetMapping("/send/private")
    public String sendPrivateMsg(@RequestParam Long userId, @RequestParam String content) throws MqttException {
        String topic = "msg/user/" + userId;
        mqttUtil.publish(topic, content, 1);
        return "Private message sent";
    }

    @GetMapping("/send/group")
    public String sendGroupMsg(@RequestParam Long groupId, @RequestParam String content) throws MqttException {
        String topic = "msg/group/" + groupId;
        mqttUtil.publish(topic, content, 1);
        return "Group message sent";
    }
}

Front‑End Integration (MQTT over WebSocket)

The existing front‑end can keep its WebSocket architecture and connect to EMQX’s 8083 port using the mqtt.js library.

<script src="https://cdn.jsdelivr.net/npm/mqtt@3/dist/mqtt.min.js"></script>
<script>
  const client = mqtt.connect('ws://127.0.0.1:8083/mqtt');
  const userId = 10001;
  const privateTopic = `msg/user/${userId}`;

  client.on('connect', () => {
    client.subscribe(privateTopic);
  });

  client.on('message', (topic, payload) => {
    const msg = payload.toString();
    console.log('Received real‑time message:', msg);
    // Render chat UI or notification popup
  });
</script>

Summary

WebSocket provides only a low‑level bidirectional channel; all higher‑level messaging features must be built from scratch. MQTT offers native support for massive connections, weak‑network resilience, offline storage, cluster distribution, and reliable delivery, allowing backend developers to implement publish/subscribe with minimal code and substantially lower development, operational, and failure costs.