Implementazione di una coda di lavoro con Node.js + Redis Sorted Set

Richiesta: La funzione A deve chiamare un'API di terze parti per ottenere dati, mentre l'API di terze parti è un metodo di elaborazione asincrona, dopo la chiamata restituisce dati e stato {data: "risultato della query", "status": "in elaborazione asincrona"}, quindi è necessario attendere per un po' prima di chiamare di nuovo l'API di terze parti per ottenere dati. Per evitare che l'utente debba aspettare perché l'API di terze parti è in elaborazione asincrona quando utilizza la funzione A, aggiungi la richiesta dell'utente alla coda dei compiti, restituisci dati parziali e chiudi la richiesta. Poi, in modo programmatizzato, estrai i compiti dalla coda dei compiti e chiama l'API di terze parti, se lo stato di ritorno è "in elaborazione asincrona", aggiungi di nuovo il compito alla coda dei compiti, se lo stato di ritorno è "elaborazione completata", inserisci i dati restituiti nel database.

Secondo i problemi menzionati, ho pensato di utilizzare Node.js + Redis sorted set per implementare la coda dei compiti. Node.js implementa l'API dell'applicazione per accettare le richieste degli utenti, combina i dati esistenti nel database con i dati restituiti dall'API e li restituisce agli utenti, e aggiunge i compiti alla coda dei compiti. Utilizza Node.js child process e cron per estrarre i compiti dalla coda dei compiti e eseguirli in modo programmatizzato.

Nel processo di progettazione della coda dei compiti, è necessario considerare alcuni problemi

• Esecuzione parallela di più compiti
• Unicità delle attività
• Gestione dopo il successo o il fallimento del compito

Soluzione per i problemi menzionati sopra

• L'esecuzione parallela di più compiti è implementata utilizzando Promise.all
• L'univocità delle attività è implementata utilizzando Redis sorted set. Utilizzando il timestamp come punteggio è possibile utilizzare il sorted set come list, nel momento in cui si aggiunge un compito si verifica se l'attività esiste già, durante l'esecuzione dell'attività si imposta il punteggio dell'attività a 0, ogni volta si esegue l'attività con un punteggio maggiore di 0, in modo da evitare la ripetizione dell'esecuzione del compito.
• Dopo l'esecuzione del compito, elimina il compito; se il compito fallisce, aggiorna il punteggio del compito al timestamp corrente, in modo da poter riaggiungere il compito fallito alla fine della coda dei compiti.

esempio codice

// remote_api.js 模拟第三方 API
'use strict';
const app = require('express')();
app.get('/', (req, res) => {
  setTimeout(() => {
    let arr = [200, 300]; // 200 代表成功，300 代表失败需要重新请求
    res.status(200).send({ 'status': arr[parseInt(Math.random() * 2)] });
  }, 3000);
});
app.listen('9001', () => {
  console.log('API 服务监听端口：9001');
});
// producer.js 自身应用 API，用来接受用户请求并将任务加入任务队列
'use strict';
const app = require('express')();
const redisClient = require('redis').createClient();
const QUEUE_NAME = 'queue:example';
function addTaskToQueue(taskName, callback) {
  // 先判断任务是否已经存在，存在：跳过，不存在：加入任务队列
  redisClient.zscore(QUEUE_NAME, taskName, (error, task) => {
    if (error) {
      console.log(error);
    }
      if (task) {
        console.log('任务已存在，不新增相同任务');
        callback(null, task);
      }
        redisClient.zadd(QUEUE_NAME, new Date().getTime(), taskName, (error, result) => {
          if (error) {
            callback(error);
          }
            callback(null, result);
          }
        });
      }
    }
  });
}
app.get('/', (req, res) => {
  let taskName = req.query['task-name'];
  addTaskToQueue(taskName, (error, result) => {
    if (error) {
      console.log(error);
    }
      res.status(200).send('正在查询中......');
    }
  });
});
app.listen(9002, () => {
  console.log('生产者服务监听端口：9002');
});
// consumer.js 定时获取任务并执行
'use strict';
const redisClient = require('redis').createClient();
const request = require('request');
const schedule = require('node-schedule');
const QUEUE_NAME = 'queue:expmple';
const PARALLEL_TASK_NUMBER = 2; // 并行执行任务数量
function getTasksFromQueue(callback) {
  // 获取多个任务
  redisClient.zrangebyscore([QUEUE_NAME, 1, new Date().getTime(), 'LIMIT', 0, PARALLEL_TASK_NUMBER], (error, tasks) => {
    if (error) {
      callback(error);
    }
      // 将任务分值设置为 0，表示正在处理
      if (tasks.length > 0) {
        let tmp = [];
        tasks.forEach((task) => {
          tmp.push(0);
          tmp.push(task);
        });
        redisClient.zadd([QUEUE_NAME].concat(tmp), (error, result) => {
          if (error) {
            callback(error);
          }
            callback(null, tasks);
          }
        });
      }
    }
  });
}
function addFailedTaskToQueue(taskName, callback) {
  redisClient.zadd(QUEUE_NAME, new Date().getTime(), taskName, (error, result) => {
    if (error) {
      callback(error);
    }
      callback(null, result);
    }
  });
}
function removeSucceedTaskFromQueue(taskName, callback) {
  redisClient.zrem(QUEUE_NAME, taskName, (error, result) => {
    if (error) {
      callback(error);
    }
      callback(null, result);
    }
  }
}
function execTask(taskName) {
  return new Promise((resolve, reject) => {
    let requestOptions = {
      'url': 'http://127.0.0.1:9001',
      'method': 'GET',
      'timeout': 5000
    });
    request(requestOptions, (error, response, body) => {
      if (error) {
        resolve('fallito');
        console.log(error);
        addFailedTaskToQueue(taskName, (error) => {}}
          if (error) {
            console.log(error);
          }
          }
        });
      }
        try {
          body = typeof body !== 'object' ? JSON.parse(body) : body;
        }
          resolve('fallito');
          console.log(error);
          addFailedTaskToQueue(taskName, (error, result) => {
            if (error) {
              console.log(error);
            }
            }
          });
          return;
        }
        if (body.status !== 200) {
          resolve('fallito');
          addFailedTaskToQueue(taskName, (error, result) => {
            if (error) {
              console.log(error);
            }
            }
          });
        }
          resolve('completato');
          removeSucceedTaskFromQueue(taskName, (error, result) => {
            if (error) {
              console.log(error);
            }
            }
          });
        }
      }
    });
  });
}
// Programma, ogni 5 secondi riceve nuove task da eseguire
let job = schedule.scheduleJob('*/5 * * * * *', () => {
  console.log('Ricezione nuova task');
  getTasksFromQueue((error, tasks) => {
    if (error) {
      console.log(error);
    }
      if (tasks.length > 0) {
        console.log(tasks);
        Promise.all(tasks.map(execTask))
        .then((results) => {
          console.log(results);
        }
        .catch((error) => {
          console.log(error);
        });
      }
    }
  });
});