Introduction to Network Connection Streaming

Network connection streaming is a powerful tool for handling real-time bidirectional communication. Node.js, with its non-blocking I/O and event-driven model, is particularly well-suited for working with network streams, such as TCP and HTTP.

TCP Streams

Node.js provides the net module to create TCP servers and clients, which are natural duplex streams, allowing both reading and writing data on the same connection.

Basic Example: TCP Server

In this example, we will create a simple TCP server that listens on a port and sends a response to each connected client.

javascript
99
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
›
⌄
⌄
⌄
⌄
⌄
const net = require('net');

const server = net.createServer((socket) => {
  console.log('New client connected');

  socket.on('data', (data) => {
    console.log(`Received: ${data}`);
    socket.write(`Echo: ${data}`);
  });

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

  socket.on('error', (err) => {
    console.error('Socket error:', err);
  });
});

server.listen(8080, () => {
  console.log('Server listening on port 8080');
});

TCP Client

A TCP client that connects to the previous server and sends a message.

javascript
99
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
›
⌄
⌄
⌄
⌄
const net = require('net');

const client = net.createConnection({ port: 8080 }, () => {
  console.log('Connected to server');
  client.write('Hello, server!');
});

client.on('data', (data) => {
  console.log(`Server says: ${data}`);
  client.end();
});

client.on('end', () => {
  console.log('Disconnected from server');
});

client.on('error', (err) => {
  console.error('Client error:', err);
});

HTTP Streams

Node.js also allows handling HTTP requests and responses as streams. This is useful for streaming large amounts of data, such as files or video streams.

Basic Example: HTTP Server

In this example, we will create an HTTP server that serves a large file in chunks using streams.

javascript
99
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
›
⌄
⌄
⌄
⌄
const http = require('http');
const fs = require('fs');

const server = http.createServer((req, res) => {
  const readableStream = fs.createReadStream('path/to/largeFile.txt');
  readableStream.pipe(res);

  readableStream.on('error', (err) => {
    console.error('File read error:', err);
    res.writeHead(500, { 'Content-Type': 'text/plain' });
    res.end('Internal Server Error');
  });

  res.on('error', (err) => {
    console.error('Response error:', err);
  });
});

server.listen(8080, () => {
  console.log('HTTP server listening on port 8080');
});

Streaming with WebSockets

WebSockets allow real-time bidirectional communication and are useful for applications like real-time chat and live streams. Node.js has multiple libraries to handle WebSockets, such as ws.

Basic Example: WebSocket Server

javascript
99
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
›
⌄
⌄
⌄
⌄
const WebSocket = require('ws');

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

wss.on('connection', (ws) => {
  console.log('New client connected');

  ws.on('message', (message) => {
    console.log(`Received: ${message}`);
    ws.send(`Echo: ${message}`);
  });

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

  ws.on('error', (err) => {
    console.error('WebSocket error:', err);
  });
});

Summary

Network connection streaming in Node.js allows for efficient handling of real-time bidirectional communication and data transmission. Whether using TCP, HTTP, or WebSockets, Node.js's streaming capabilities provide a strong foundation for developing robust and scalable network applications.

Network Connection Streaming Diagram