Ein vollständiges Beispiel für die Implementierung eines zeitgesteuerten Crawlers mit Nodejs

Ursache des Vorfalls

Vor ein paar Tagen musste ich meinem Freund helfen, die Captain Group von Bilibili zu überprüfen. Die Captain List einzeln zu durchsuchen ist natürlich nicht die erste Wahl für einen Programmierer. Das Richtige ist, die Aufgabe dem Computer zu überlassen und ihn sie selbst erledigen zu lassen. Theorie geklärt, jetzt kann es mit dem Codieren losgehen.

Da der API-Crawler der bekannten Kapitänsliste Axios verwendet, um direkt auf die Schnittstelle zuzugreifen

Also habe ich ein wenig Zeit damit verbracht, diesen Crawler zu schreiben, den ich bilibili-live-captain-tools 1.0 genannt habe

const axios = erfordern('axios')
const Zimmer-ID = "146088"
const ruid = "642922"
const url = `https://api.live.bilibili.com/xlive/app-room/v2/guardTab/topList?roomid=${roomid}&ruid=${ruid}&page_size=30`

const Kapitän = {
 1: 'Gouverneur',
 2: 'Admiral',
 3: „Kapitän“
}

const reqPromise = url => axios.get(url);

let CaptinList = []
let Benutzerliste = []

asynchrone Funktion Crawler (URL, SeiteJetzt) ​​{
 const res = warte auf reqPromise(URL);
 wenn (pageNow == 1) {
 CaptinList = CaptinList.concat(res.data.data.top3);
 }
 CaptinList = CaptinList.concat(res.data.data.list);
}


Funktion getMaxPage(res) {

 const Info = res.data.data.info
 const { Seite: maxPage } = Info
 returniere maxPage
}


Funktion getUserList(res) {

 für (let item of res) {
 const Benutzerinfo = Element
 const { uid, Benutzername, Guard_Level } = Benutzerinfo
 UserList.push({ uid, Benutzername, Captin: Captin[guard_level] })
 }
}

asynchrone Funktion main(UID) {
 const maxPage = warte auf reqPromise(`${url}&page=1`).then(getMaxPage)
 für (let pageNow = 1; pageNow < maxPage + 1; pageNow++) {
 const URL = `${url}&page=${pageNow}`;
 warte auf Crawler (URL, SeiteJetzt);
 }
 getUserList(Kapitänsliste)
 console.log(Suche(UID, Benutzerliste))
 Suche zurückgeben (UID, Benutzerliste)
}

Funktion Suche(UID, Benutzerliste) {
 für (lass i = 0; i < UserList.length; i++) {
 wenn (Benutzerliste[i].uid === uid) {
 Benutzerliste[i] zurückgeben;
 }
 }
 Rückgabe 0
}

modul.exporte = {
 hauptsächlich
}

Offensichtlich kann dieser Crawler nur manuell ausgelöst werden und benötigt eine Befehlszeile und eine Knotenumgebung, um direkt ausgeführt zu werden. Daher habe ich mit Koa2 einen Seitendienst dafür geöffnet und eine äußerst einfache Seite geschrieben

const Koa = erfordern('koa');
const app = new Koa();
const Pfad = require('Pfad')
const fs = erfordern('fs');
const router = erfordern('koa-router')();
const index = erfordern('./index')
const Ansichten = erforderlich('koa-views')



app.use(Ansichten(Pfad.join(__dirname, './'), {
 Erweiterung: „ejs“
}))
app.use(router.routes());

router.get('/', async ctx => {
 ctx.response.type = "html";
 ctx.response.body = fs.createReadStream('./index.html');
})

router.get('/api/captin', async (ctx) => {
 const UID = ctx.request.query.uid
 Konsole.log (UID)
 const Info = warte auf index.main(parseInt(UID))
 warte auf ctx.render('index', {
 Info,
 })
});

app.listen(3000);

Da die Seite weder über eine Drosselung noch über einen Anti-Shake-Schutz verfügt, kann die aktuelle Version nur in Echtzeit gecrawlt werden. Die Wartezeit ist lang und häufige Aktualisierungen lösen natürlich den Anti-Crawler-Mechanismus der B-Station aus, sodass die aktuelle Server-IP einer Risikokontrolle unterliegt.

So entstand bilibili-live-captain-tools 2.0

Funktion Drosselklappe(fn, Verzögerung) {
 var Zeitgeber;
 Rückgabefunktion () {
 var _this = dies;
 var args = Argumente;
 wenn (Zeitgeber) {
  zurückkehren;
 }
 Timer = setzeTimeout(Funktion () {
  fn.apply(_this, args);
  timer = null; // Lösche den Timer nach der Ausführung von fn nach der Verzögerung. Zu diesem Zeitpunkt ist der Timer falsch und der Gashebel kann den Timer eingeben}, Verzögerung)
 }
}

Fügen Sie Drosselung und Anti-Shake hinzu und verwenden Sie einen Pseudo-Echtzeit-Crawler (durchsucht einmal pro Minute die geplanten Aufgaben).

In diesem Fall müssen wir das Crawler-Skript regelmäßig ausführen. Zu diesem Zeitpunkt dachte ich daran, die Planungsfunktion von Egg zu verwenden, aber ich möchte kein so „übertriebenes“ Crawler-Programm erstellen. Wenn ich Zweifel habe, suche ich einfach auf Baidu. Wir haben also folgenden Plan

Verwenden Sie Node Schedule, um geplante Aufgaben zu implementieren

Node Schedule ist ein flexibler Cron- und Nicht-Cron-Job-Scheduler für Node.js. Sie können damit einen Job (eine beliebige Funktion) so planen, dass er an bestimmten Terminen ausgeführt wird, mit optionalen Wiederholungsregeln. Es wird jeweils nur ein Timer verwendet (anstatt anstehende Jobs jede Sekunde/Minute neu zu bewerten).

1. Installieren Sie node-schedule

npm installiere Node-Schedule
# oder yarn add node-schedule

2. Grundlegende Verwendung

Schauen wir uns die offiziellen Beispiele an.

const Zeitplan = erforderlich('Knotenplan');

const job = schedule.scheduleJob('42 * * * *', function(){
 console.log('Die Antwort auf das Leben, das Universum und den ganzen Rest!');
});

Der erste Parameter von schedule.scheduleJob muss gemäß den folgenden Regeln eingegeben werden

Knotenplanregeln werden in der folgenden Tabelle angezeigt

* * * * * *
┬ ┬ ┬ ┬ ┬ ┬
│ │ │ │ │ |
│ │ │ │ │ └ Wochentag, Wertebereich: 0 - 7, wobei 0 und 7 jeweils für Sonntag stehen. │ │ │ │ └─── Monat, Wertebereich: 1 - 12
│ │ │ └────── Datum, Wert: 1 - 31
│ │ └───────── , Wert: 0 - 23
│ └──────────── Punkte, Wert: 0 - 59
└──────────────── Sekunden, Wert: 0 - 59 (optional)
Sie können auch eine bestimmte Zeit angeben, zum Beispiel: const date = new Date()

Verstehen Sie die Regeln und setzen Sie selbst welche um

const Zeitplan = erforderlich('Knotenplan');

// Definieren Sie eine Zeit let date = new Date(2021, 3, 10, 12, 00, 0);

// Eine Aufgabe definieren let job = schedule.scheduleJob(date, () => {
 console.log("Aktuelle Zeit:",neues Datum());
});

Das obige Beispiel bedeutet, dass die Uhrzeit am 10.03.2021 um 12:00 Uhr gemeldet wird.

3. Erweiterte Nutzung

Zusätzlich zur grundlegenden Verwendung können wir auch einige flexiblere Methoden verwenden, um geplante Aufgaben zu implementieren.

3.1. Einmal pro Minute ausführen

const Zeitplan = erforderlich('Knotenplan');

//Regeln definieren let rule = new schedule.RecurrenceRule();
Regel.Sekunde = 0
//Einmal pro Minute bei 0 Sekunden ausführen //Aufgabe starten let job = schedule.scheduleJob(rule, () => {
 console.log(neues Datum());
});

Die Regel unterstützt die folgenden Werte: Sekunde, Minute, Stunde, Datum, Wochentag, Monat, Jahr usw.

Einige allgemeine Regeln sind in der folgenden Tabelle aufgeführt:

Ausführungen pro Sekunde
Regel.Sekunde = [0,1,2,3......59];
Jede Minute bei 0 Sekunden ausführen
Regel.Sekunde = 0;
Alle 30 Minuten ausführen
Regel.Minute = 30;
Regel.Sekunde = 0;
Wird täglich um 0:00 Uhr ausgeführt
Regel.Stunde =0;
Regel.Minute =0;
Regel.Sekunde =0;
Ausgeführt um 10:00 Uhr am 1. jedes Monats
Regel.Datum = 1;
Regel.Stunde = 10;
Regel.Minute = 0;
Regel.Sekunde = 0;
Wird jeden Montag, Mittwoch und Freitag um 0:00 und 12:00 Uhr ausgeführt
Regel.Wochentag = [1,3,5];
Regel.Stunde = [0,12];
Regel.Minute = 0;
Regel.Sekunde = 0;

4. Beendigung des Auftrags

Mit „cancel()“ können Sie eine laufende Aufgabe beenden. Wenn bei einer Aufgabe eine Anomalie auftritt, brechen Sie die Aufgabe rechtzeitig ab

job.abbrechen();

Zusammenfassen

node-schedule ist ein Crontab-Modul für Node.js. Wir können geplante Aufgaben verwenden, um das Serversystem zu warten, sodass es in einem festgelegten Zeitraum bestimmte notwendige Vorgänge ausführen kann. Wir können geplante Aufgaben auch verwenden, um E-Mails zu senden, Daten zu crawlen usw.

Dies ist das Ende dieses Artikels über die Implementierung geplanter Crawler mit Nodejs. Weitere relevante Inhalte zu geplanten Crawlern mit Nodejs finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, dass jeder 123WORDPRESS.COM in Zukunft unterstützen wird!