How WebSocket Powers Real-Time IoT Devices: Architecture & Code Walkthrough

1. Technical Background

With the rapid growth of Internet of Things (IoT) technology, numerous IoT devices have emerged and deeply integrated into daily life. Traditional fish tanks lack remote functions such as feeding and pump control, whereas smart fish tanks combine traditional tanks with internet technology, allowing users to operate feeding, pump switches, and lighting remotely via a mobile app, with results synchronized in real time.

In client‑server communication, HTTP is commonly used, but its stateless nature prevents the server from proactively pushing messages to specific clients. Consequently, clients must poll repeatedly to obtain the latest data, which incurs high network costs, latency, and server load, especially under heavy request volumes, and creates challenges for multi‑device data sharing. To address these issues, WebSocket technology is introduced.

2. Introduction to WebSocket

WebSocket is a TCP‑based full‑duplex communication protocol. In the WebSocket API, the browser and server complete a single handshake to establish a persistent connection for bidirectional data transfer. Compared with HTTP, WebSocket offers significant advantages:

Real‑time: WebSocket delivers instant data transmission via a persistent connection, enabling the server to push the latest data to the client without polling, making it ideal for chat, real‑time games, and other frequently updating scenarios.

Reduced traffic and resource consumption: After the connection is established, subsequent WebSocket communication does not repeatedly carry HTTP headers, reducing data volume and avoiding the overhead of repeatedly opening and closing connections in non‑persistent HTTP mode.

Optimized resource utilization: WebSocket defines binary frames, which are better suited for handling binary content, further improving resource efficiency.

3. Technology Selection

WebSocket implementations in Java include Java WebSocket API, Spring Boot WebSocket, Tomcat WebSocket, Netty, and others.

For typical enterprise applications with modest concurrency and modest performance requirements, the Java WebSocket API is an appropriate choice. However, high‑concurrency internet applications may require extensive performance tuning and extensions to meet demand.

Netty adopts an asynchronous non‑blocking I/O model, efficiently utilizing system resources, handling large numbers of WebSocket connections and messages, and significantly improving throughput and response speed in high‑concurrency scenarios. For maximum performance and scalability, Netty is recommended for implementing the WebSocket server.

4. WebSocket Practice in Dangbei Smart Devices

4.1 Overall Architecture Design

The overall architecture of the WebSocket service in Dangbei smart devices is as follows:

When an IoT device is activated or started, it sends a connection request to the IoT WebSocket service cluster, establishing and maintaining a long‑lived connection, while the cluster synchronizes device information to the application server. The client app also establishes a persistent connection with the client‑side WebSocket cluster upon launch.

User operations on the IoT device or the app are communicated through the WebSocket service cluster, achieving near‑real‑time data updates.

4.2 Implementation Process

1. IoT Device Establishes Connection

The process for an IoT device to establish and maintain a long‑lived connection:

Device requests to establish a WebSocket connection.

The service cluster creates and maintains the connection, stores device information, and sends a connection‑success response.

The device periodically sends heartbeats (PING); the cluster replies with PONG to keep the connection alive.

2. Client APP Establishes Connection

When the user opens the client APP, the following steps occur:

APP requests to establish a WebSocket connection.

The service cluster creates and maintains the connection, stores client information, and sends a connection‑success response.

APP periodically sends heartbeats (PING); the cluster replies with PONG.

3. User Operates IoT Device

The flow when a user issues a command to an IoT device:

IoT device sends the operation command to the service cluster.

The service cluster parses the command and forwards it to the application server.

The application server processes the command and pushes updated data to the client service cluster.

The client service cluster receives the update and pushes it to the client APP for the user to view.

4. User Operates Client APP

The flow when a user interacts with the client APP:

Client APP sends an operation command to the service cluster.

The service cluster forwards the command to the IoT WebSocket service cluster.

The IoT WebSocket service cluster parses the command and forwards it to the IoT device.

The IoT device executes the command, and the application server updates data.

4.3 Core Code Examples

1. Main Process Orchestration

<code>public class WebSocketBroker implements ApplicationListener<ApplicationReadyEvent> {
    // ...
    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            EventLoopGroup bossGroup = buildBossGroup();
            EventLoopGroup workerGroup = buildWorkerGroup();

            serverBootstrap.group(bossGroup, workerGroup)
                .channel(buildChannelClass())
                .option(ChannelOption.SO_BACKLOG, webSocketConfig.getBacklog())
                .childOption(ChannelOption.SO_KEEPALIVE, true)
                .childOption(ChannelOption.TCP_NODELAY, true)
                .childHandler(webSocketChannelInitializer);
            serverBootstrap.bind(webSocketConfig.getWsPort()).sync();
        } catch (Exception e) {
            // exception handling
        }
    }
}
</code>

2. Processing Logic

<code>public class WebSocketChannelInitializer extends ChannelInitializer<SocketChannel> {
    @Resource
    private WebSocketConfig webSocketConfig;
    @Resource
    private AuthHandler authHandler;
    @Resource
    private WebSocketHandler webSocketHandler;

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ch.pipeline()
            // http decoder
            .addLast(new HttpServerCodec())
            // support for large data streams
            .addLast(new ChunkedWriteHandler())
            // connection authentication
            .addLast(authHandler)
            // idle detection
            .addLast(new IdleStateHandler(0, 0, webSocketConfig.getAllIdleTime(), TimeUnit.SECONDS))
            // protocol upgrade handling
            .addLast(new WebSocketServerProtocolHandler(webSocketConfig.getWsPath(), null, true, 65536, true))
            // business logic handling
            .addLast(webSocketHandler);
    }
    // ...
}
</code>

3. Connection Authentication

<code>public class AuthHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception {
        try {
            // connection authentication logic...
            ctx.pipeline().remove(this);
            ctx.fireChannelRead(request.retain());
        } catch (Exception e) {
            log.error("[Connection Auth] Exception, request={}", JSON.toJSONString(request), e);
            ctx.channel().disconnect();
        }
    }
    // ...
}
</code>

4. Business Message Handling

<code>public class WebSocketHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {
    @Resource
    private ConnectEventHandler connectEventHandler;

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame frame) throws Exception {
        try {
            String text = frame.text();
            log.debug("[Handle Text Message] text={}", JSON.toJSONString(text));
            // ...
        } catch (Exception e) {
            log.error("[Handle Text Message] Exception, text={}", JSON.toJSONString(text), e);
        }
    }

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        // event handling
        if (evt instanceof WebSocketServerProtocolHandler.HandshakeComplete) {
            connectEventHandler.handle(ctx.channel());
        } else if (evt instanceof IdleStateEvent) {
            ctx.channel().disconnect();
        } else {
            super.userEventTriggered(ctx, evt);
        }
    }
    // ...
}
</code>

5. Summary

This article detailed the application of WebSocket technology in Dangbei IoT smart devices, noting its deployment in large‑screen karaoke, payment, and smart fish‑tank scenarios, and expressing optimism for broader future use.