Devity - Basics of web socket

Basics of web socket

WebSocket is a communication protocol that provides full-duplex (two-way) communication channels over a single TCP connection. It is commonly used for real-time web applications where low latency and efficient communication are required, such as chat applications, online gaming, live notifications, and stock market updates.

Key Features of WebSocket:

Full-Duplex Communication:
- Both the client and server can send and receive messages independently at the same time.
- This contrasts with HTTP, where the client must always initiate communication.
Persistent Connection:
- WebSocket keeps the connection open, reducing the overhead of repeatedly opening and closing connections, as seen with HTTP requests.
- This makes it highly efficient for applications requiring continuous data exchange.
Low Latency:
- Messages can be sent and received in near real-time due to the persistent nature of the connection.
Lightweight:
- The protocol uses a small header after the initial handshake, minimizing data overhead compared to HTTP.
Bidirectional Messaging:
- Either party (client or server) can send messages whenever needed without waiting for a request.

How WebSocket Works:

Handshake:
- A WebSocket connection begins with an HTTP request (the handshake) sent by the client to the server.
- The client includes the Upgrade header in the request to indicate it wants to switch to the WebSocket protocol.
- If the server supports WebSocket, it responds with a 101 Switching Protocols status, and the connection upgrades to WebSocket.
Data Exchange:
- Once established, messages can be sent in both directions using a lightweight framing mechanism.
Closure:
- Either the client or the server can close the connection when it is no longer needed.

Use Cases:

Chat Applications: Enables real-time messaging between users.
Live Notifications: Pushes updates (e.g., sports scores, social media notifications) instantly.
Collaborative Tools: Supports live collaboration in apps like Google Docs.
IoT Devices: Facilitates communication between IoT devices and servers.
Gaming: Provides low-latency updates for multiplayer games.

Example:

Here’s a simple WebSocket communication flow:

Client Request:
GET /chat HTTP/1.1

Host: example.com

Upgrade: websocket

Connection: Upgrade

Sec-WebSocket-Key: x3JJHMbDL1EzLkh9GBhXDw==

Sec-WebSocket-Version: 13

Server Response:
HTTP/1.1 101 Switching Protocols

Upgrade: websocket

Connection: Upgrade

Sec-WebSocket-Accept: HSmrc0sMlYUkAGmm5OPpG2HaGWk=

Once established, the connection can transmit binary or text data until closed.

Here’s a simple demonstration of how WebSocket communication works using Python with the websockets library.

WebSocket Server

Below is a basic WebSocket server that listens for messages and echoes them back to the client:

WebSocket Client

A simple WebSocket client that connects to the server and sends a message:

Steps to Test:

Save the server code in one Python file (e.g., server.py) and the client code in another file (e.g., client.py).

Run the server first using:
python server.py

Then run the client using:
python client.py

Expected Output:

Server Output:

WebSocket server running on ws://localhost:8765

Received: Hello, WebSocket!

Client Output:

Sent: Hello, WebSocket!

Received: Echo: Hello, WebSocket!

Explanation:

Server:
- Listens on ws://localhost:8765.
- When a message is received, it echoes it back to the client.
Client:
- Connects to the server.
- Sends the message "Hello, WebSocket!".
- Receives and prints the server's echo response.

This basic example demonstrates the WebSocket protocol's bidirectional communication.

Page updated

Google Sites

Report abuse