firebase
Firebase-Warteschlange

So verwenden Sie die Firebase-Warteschlange als Backend für Ihre Anwendung

Firebase bietet Backend als Dienst an. Als Anwendungsentwickler haben Sie keine Option für Backend-Code.

Dieses Beispiel zeigt, wie Sie mit der Firebase-Warteschlange ein Backend erstellen, das auf der Firebase-Datenbank ausgeführt wird, und als Backend für Ihre Frontend-Anwendung dienen.

Bevor Sie in den Code einsteigen, können Sie die Architektur und deren Funktionsweise verstehen. Der Kürze halber nehmen wir an, dass wir eine Website als Frontend und einen NodeJs-Server als Backend verwenden

Voraussetzungen

1. Erstellen Sie eine Firebase-Anwendung mit Ihrem Google-Konto

2. Fügen Sie Ihrer Webseite Firebase hinzu. Verwenden Sie bower install firebase --save

3. Erstellen Sie ein Dienstkonto mit Ihrem neu erstellten Firebase-Konto (Einstellungen -> Berechtigungen -> Dienstkonten -> SERVICEKONTO ERSTELLEN -> (geben Sie den Namen an und aktivieren Sie das Kontrollkästchen "Neuen privaten Schlüssel einrichten") -> Speichern Sie die Json-Datei, die wir benötigen das später

4. Konfigurieren Sie den NodeJs-Server, der in Ihrer bevorzugten Umgebung gehostet werden kann

5. Erstellen Sie den folgenden Endpunkt innerhalb der queue/specs

   "request_response":

    {
        "error_state": "request_error_processing",
        "finished_state": "finished_state",
        "in_progress_state": "request_in_progress",
        "start_state": "request_started"
    }
   

6. Installieren Sie in NodeJs Server die Version der Firebase-Serverseite, npm install firebase --save und initialisieren Sie Ihr Dienstkonto mithilfe der Json-Datei, die wir aus Schritt 3 erhalten haben. Es sieht so aus

   firebase.initializeApp ({serviceAccount: './Ihr_Datei.json', databaseURL: 'get_from_firebase_account'});

Die Architektur

Hier ist der ganze Zyklus, wie es funktioniert.

Auf der Frontend-Seite werden Sie diese Schritte ausführen

1. Mit firebase web sdk schreiben Sie Ihre Anforderungen direkt in die firebase-Datenbank im Endpunkt 'Warteschlange / Tasks'. Rufen Sie diese Anforderung an, die Sie an das Backend senden.
2. Nach dem Einfügen Ihrer Aufgabe registrieren Sie Listener in der Endpunktwarteschlange queue/tasks/{taskKey} die aufgerufen wird, wenn das Backend Ihre Anfrage verarbeitet und die Antwort in die obige Task schreibt

Auf der Backend-Seite werden Sie diese Schritte ausführen

1. Server erstellen, der Endpunkt 'Warteschlange / Aufgaben' unendlich überwacht
2. Verarbeitet Ihre Aufgaben und schreibt die Antwortdaten in die queue/tasks/response
3. Entfernen Sie die Aufgabe

Erstellen Sie zunächst diese Hilfsfunktion, mit der Sie Rückrufe und Versprechen gemeinsam bearbeiten können

function createPromiseCallback() {
    var cb;
    var promise = new Promise(function (resolve, reject) {
        cb = function (err, data) {
            if (err) return reject(err);
            return resolve(data);
        };
    });
    cb.promise = promise;
    return cb;
}

Im Frontend haben Sie diese Funktion

function sendRequest(kind, params, cb) {

    cb = cb || createPromiseCallback();
    var requestObject = {
        kind: kind,
        params: params
    };
    var tasksRef = firebase.database().ref('queue/tasks');

    var requestKey = tasksRef.push().key;

    var requestRef = tasksRef.child(requestKey);

    function requestHandshake(snap) {
        if (snap && snap.exists() && (snap.val().response || snap.val()._state ===    config.firebase.task.finishState || snap.val()._error_details)) {
            var snapVal = snap.val();
            if (snapVal._error_details) {
                cb(snapVal._error_details.error);
            } else {
            cb(null, snapVal.response);
        }
        requestRef.off('value', requestHandshake);
    }
   }

   var bulkUpdate = {};
   bulkUpdate['queue/tasks/' + requestKey + '/request'] = requestObject;
   bulkUpdate['queue/tasks/' + requestKey + '/_state'] = config.firebase.task.startState;

   firebase.database().ref().update(bulkUpdate)
    .then(function (snap) {
        requestRef.on('value', requestHandshake);
    }).catch(function (err) {
        cb(err);
    });

   return cb.promise;
  }

Sie können diese Funktion wie sendRequest('CreateHouseFacade', {houseName:'Test'}) .

Kind-Parameter sind für das Backend, um zu wissen, welche Methode für die Verarbeitung der Anforderung aufgerufen wird. Params dient zum Übergeben zusätzlicher Parameterinformationen.

Und hier ist der Backend-Code

const database = firebase.database();
const queueRef = database.ref('queue');

const queueOptions = {
    'specId': 'request_response',
    'sanitize': false,
    'suppressStack': false,
    'numWorkers': 3
};

function removeTask(task) {
    var taskRef = queueRef.child(`tasks/${task._id}`);
    return taskRef.remove();
}

function processTask(data, progress, resolve, reject) {
    try {
        requestHandler(data.request).then(response => {
            data.response = response || null;
            return resolve(data);
        }).catch(err => {
            return reject(err);
        }).then(snap => {
            removeTask(data);
        });
    } catch (err) {
        reject(err).then(snap => removeTask(data));
    }
}

function requestHandler(request) {
    if (!request || !request.kind) throw new Error('Absent Request or Kind');
    var deferredResponse = requestHandlerFactory(request.kind, request.params);
    return deferredResponse;
}

function requestHandlerFactory(kind, params) {
    // It includes mapping all your backend services
    switch (kind) {
        case 'CreateHouseFacade': return myService(params)
        default: throw new Error(`Invalid kind ${kind} was specified`);
    }
}

Die Funktion myService enthält Ihren Geschäftslogikcode, der die CreateHouseFacade Anforderung CreateHouseFacade .