How to implement nodejs long connection

Node.js is a very popular server-side JavaScript runtime environment. It excels in network programming, especially in implementing long-lived connections.

In network programming, a long connection refers to a state in which the client and server maintain heartbeat activity and do not close the connection. Compared with the traditional HTTP request-response model, long connections can improve network efficiency and system performance. For example, when sending and receiving data through a long connection between the client and the server, the overhead of connection establishment and disconnection can be reduced, and the resulting network delay and system resource waste can be avoided.

So, how to implement long connections in Node.js?

1. Using WebSocket

WebSocket is a protocol built on the TCP protocol to achieve full-duplex communication. It provides a way to establish a long connection between the client and the server, enabling two-way communication instead of just client request-server response.

In Node.js, you can use the ws library to implement WebSocket connection. The following is a simple WebSocket example:

<code>const WebSocket = require('ws');

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

wss.on('connection', function connection(ws) {
  console.log('client connected');

  ws.on('message', function incoming(message) {
    console.log('received: %s', message);
  });

  ws.on('close', function close() {
    console.log('client disconnected');
  });
});</code>

In this example, we create a WebSocket server listening on port 8080. When a client connects to the server, the WebSocket server will call the connection callback function through the event handler. In this callback function, we can register a message event handler to receive messages sent by the client. And we also registered the close event handler to handle when the client disconnects.

2. Using TCP Socket

TCP Socket is a basic module in Node.js, used to implement socket communication of the TCP protocol. In Node.js, you can use the net module to operate TCP Socket.

The following is a simple TCP Socket example:

<code>const net = require('net');

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

  socket.on('data', function(data) {
    console.log('received: ' + data);
  });

  socket.on('end', function() {
    console.log('client disconnected');
  });
});

server.listen(8080, function() {
  console.log('server started');
});</code>

In this example, we create a TCP Socket server listening on port 8080. When the client connects to the server, we output a log and then register the data event handler to receive the data sent by the client. When the connection ends, we output another log.

3. Use HTTP long polling

HTTP long polling is a technology that establishes long connections in web applications. It is implemented through the long connection mechanism of the HTTP protocol, which enables the server to push data to the client.

In Node.js, we can implement HTTP long polling connections ourselves. The following is a simple HTTP long polling example:

<code>const http = require('http');
const messages = [];

http.createServer(function(req, res) {
  console.log('client connected');

  if (req.method === 'POST') {
    let chunks = '';

    req.on('data', function(chunk) {
      chunks += chunk;
    });

    req.on('end', function() {
      messages.push(chunks);
      console.log('message received: ' + chunks);
    });
  } else if (req.method === 'GET') {
    res.writeHead(200, { 'Content-Type': 'text/plain', 'Connection': 'keep-alive', 'Cache-Control': 'no-cache' });

    let lastMessageIndex = 0;

    function checkForNewMessages() {
      if (lastMessageIndex < messages.length) {
        res.write(messages.slice(lastMessageIndex).join('\n') + '\n');
        lastMessageIndex = messages.length;
      }
    }

    setInterval(checkForNewMessages, 1000);
    checkForNewMessages();
  }
}).listen(8080);</code>

In this example, we create an HTTP server listening on port 8080. By checking the method of the request (GET or POST) we can convert the request to a long polling mechanism. In a long-polling request, we send a 200 response code, Connection header, and Cache-Control header to the client to indicate that we will keep the connection alive. Then, we use the setInterval function and checkForNewMessages function to continuously check the latest messages, and if there are new messages, send them to the client.

Summary

In Node.js, long connections can be implemented using a variety of technologies such as WebSocket, TCP Socket and HTTP long polling. The specific choice depends on the application needs and design. Of course, there are other more advanced technologies, such as Socket.IO, etc., that can provide more functions and flexibility.

The above is the detailed content of How to implement nodejs long connection. For more information, please follow other related articles on the PHP Chinese website!