Wat is de meest efficiënte node.js communicatiebibliotheek/methode tussen processen?

Als u berichten van de ene machine naar de andere wilt verzenden en niet geïnteresseerd bent in terugbellen, dan is Redis pub/sub de beste oplossing. Het is heel gemakkelijk te implementeren en Redis is erg snel.

Eerst moet je Redis op een van je machines installeren.

Het is heel eenvoudig om verbinding te maken met Redis:

var client = require('redis').createClient(redis_port, redis_host);

Maar vergeet niet de Redis-poort in uw firewall te openen!

Vervolgens moet je elke machine op een kanaal abonneren:

client.on('ready', function() {
  return client.subscribe('your_namespace:machine_name');
});

client.on('message', function(channel, json_message) {
  var message;
  message = JSON.parse(message);
  // do whatever you vant with the message
});

Je mag your_namespace overslaan en gebruik een globale naamruimte, maar u zult er vroeg of laat spijt van krijgen.

Het is ook heel gemakkelijk om berichten te verzenden:

var send_message = function(machine_name, message) {
  return client.publish("your_namespace:" + machine_name, JSON.stringify(message));
};

Als u verschillende soorten berichten wilt verzenden, kunt u p-berichten gebruiken in plaats van berichten:

client.on('ready', function() {
  return client.psubscribe('your_namespace:machine_name:*');
});

client.on('pmessage', function(pattern, channel, json_message) {
  // pattern === 'your_namespace:machine_name:*'
  // channel === 'your_namespace:machine_name:'+message_type
  var message = JSON.parse(message);
  var message_type = channel.split(':')[2];
  // do whatever you want with the message and message_type
});

send_message = function(machine_name, message_type, message) {
  return client.publish([
    'your_namespace',
    machine_name,
    message_type
  ].join(':'), JSON.stringify(message));
};

Het beste is om uw processen (of machines) een naam te geven op basis van hun functionaliteit (bijv. 'send_email' ). In dat geval kan het proces (of de machine) op meer dan één kanaal zijn geabonneerd als het meer dan één functionaliteit implementeert.

Het is eigenlijk mogelijk om een ​​bidirectionele communicatie op te bouwen met redis. Maar het is lastiger omdat je een unieke naam van het terugbelkanaal aan elk bericht moet toevoegen om teruggebeld te worden zonder de context te verliezen.

Dus mijn conclusie is deze:Gebruik Redis als je communicatie "verzenden en vergeten" nodig hebt, onderzoek een andere oplossing als je volwaardige tweerichtingscommunicatie nodig hebt .