Schnellstarter
Wie man ein Backend für React Native erstellt?

38min
Einführung
In diesem Tutorial lernen Sie wie man ein Backend für React Native mit Back4App erstellt. 
Wir werden uns auf die plattformübergreifende Kompatibilität konzentrieren und zeigen, wie Sie wesentliche Back4App-Funktionen für Datenmanagement, Benutzerauthentifizierung und Echtzeitdaten integrieren können. 
Durch die Nutzung von REST- und GraphQL-APIs können Sie Ihr React Native-Projekt so entwickeln, dass es sowohl auf iOS- als auch auf Android-Plattformen läuft, und so ein nahtloses Erlebnis über native Komponenten und mobile Anwendungen hinweg gewährleisten.
Die Implementierung sicherer Benutzeranmeldungen, die Planung von Aufgaben und die Nutzung von Echtzeitanwendungen werden Ihre Reise als Full-Stack-Entwickler erleichtern. 
Sie werden auch sehen, wie die Umgebung von Back4App die Zeit reduzieren kann, die benötigt wird, um Dienste wie Hosting, Datenbank und Sicherheitslayer einzurichten. 
Am Ende werden Sie eine robuste Backend-Struktur haben, die Ihre React Native-App unterstützt und den Weg für den Aufbau mobiler Lösungen in großem Maßstab ebnet.
Nach Abschluss dieses Leitfadens sind Sie bereit, Ihre App mit erweiterten Funktionen zu erweitern, Drittanbieterdienste zu integrieren oder Ihr Projekt in eine produktionsbereite Plattform zu verwandeln. 
Lass uns in die moderne Entwicklung mobiler Apps mit Back4App und React Native eintauchen!
Voraussetzungen
Um dieses Tutorial abzuschließen, benötigen Sie:
Ein Back4app-Konto und ein neues Back4App-Projekt
Erste Schritte mit Back4app.
Wenn Sie kein Konto haben, melden Sie sich kostenlos an. Folgen Sie dann der Anleitung, um Ihr Projekt vorzubereiten.
Grundlegende React Native-Entwicklungsumgebung
Sie können die React Native CLI Quickstart oder Expo CLI. Stellen Sie sicher, dass Sie Node.js installiert haben.
Node.js (Version 14 oder höher) installiert
Sie benötigen Node.js, um npm-Pakete zu installieren und lokale Entwicklungsserver auszuführen. Node.js installieren﻿
Vertrautheit mit JavaScript und grundlegenden React Native-Konzepten
Offizielle React Native-Dokumentation.
Wenn Sie neu in der React Native-Entwicklung sind, lesen Sie zuerst die Dokumentation oder ein Tutorial für Anfänger.
Stellen Sie sicher, dass Sie diese Voraussetzungen erfüllt haben, bevor Sie beginnen. Wenn Ihr Back4App-Projekt erstellt und Ihre lokale React Native-Umgebung konfiguriert ist, wird der Prozess reibungslos verlaufen.
Schritt 1 – Erstellen eines neuen Projekts auf Back4App und Verbindung herstellen
Ein neues Projekt erstellen
Der erste Schritt beim Erstellen mobiler Backends für Ihre React Native-App besteht darin, ein neues Projekt auf Back4App zu erstellen. Befolgen Sie diese Schritte:
Melden Sie sich bei Ihrem Back4App-Konto an.
Klicken Sie auf die Schaltfläche „Neue App“ in Ihrem Back4App-Dashboard.
Geben Sie Ihrer App einen Namen (z. B. „ReactNative-Backend-Tutorial“).
﻿
Sobald das Projekt erstellt ist, wird es in Ihrem Back4App-Dashboard angezeigt. Sie werden dieses neue Projekt verwenden, um Daten zu verwalten und die Sicherheit für Ihre React Native-App zu konfigurieren.
Erhalten Ihrer Anwendungs-Schlüssel
Im Gegensatz zu webbasierten React-Apps erfordert die Entwicklung von React Native häufig direkte HTTP-Anfragen zum Abrufen und Manipulieren von Daten. Da wir uns auf REST-APIs (oder GraphQL-APIs) anstelle des Parse SDK konzentrieren, benötigen Sie dennoch Ihre Back4App-Schlüssel, um authentifizierte Anfragen zu senden.
Holen Sie sich Ihre Parse-Schlüssel:
Öffnen Sie im Back4App-Dashboard die App-Einstellungen oder den Sicherheits- & Schlüssel-Bereich, um Ihre Anwendungs-ID, REST-API-Schlüssel, und GraphQL-Endpunkt zu finden (normalerweise https://parseapi.back4app.com/graphql).
Notieren Sie Ihren REST-API-Schlüssel:
Sie werden ihn in Ihren React Native fetch oder axios-Header einfügen, um jede Anfrage zu authentifizieren.
﻿
Dieser Schritt stellt sicher, dass Ihre mobilen Anwendungen sicher mit Back4App kommunizieren können.
Schritt 2 – Einrichten der Datenbank
Back4App bietet eine Vielzahl von Backend-Optionen für React Native-Apps, einschließlich robuster Datenverwaltungsfunktionen. Sie können Klassen erstellen, Felder hinzufügen und Beziehungen über das Dashboard definieren. Egal, ob Sie Echtzeitanwendungen oder einfachere CRUD-Apps erstellen, das Back4App-Dashboard hilft Ihnen, Daten einfach zu speichern und zu organisieren.
Erstellen eines Datenmodells
Navigieren Sie zum Abschnitt „Datenbank“ in Ihrem Back4App-Dashboard.
Erstellen Sie eine neue Klasse (z. B. „Todo“) und fügen Sie relevante Spalten wie Titel (String) und isCompleted (Boolean) hinzu.
Neue Klasse erstellen
﻿
Back4App unterstützt verschiedene Datentypen: String, Zahl, Boolean, Objekt, Datum, Datei, Zeiger, Array, Beziehung, GeoPoint, und Polygon. Sie können auch Parse erlauben, Felder automatisch zu erstellen, wenn Sie neue Daten senden.
Erstellen eines Datenmodells mit AI-Agent
Wenn Sie möchten, können Sie den Back4App AI-Agenten verwenden:
Öffnen Sie den KI-Agenten von Ihrem App-Dashboard.
Beschreiben Sie Ihr Datenmodell in einfacher Sprache (z.B. „Erstellen Sie eine Todo-Klasse mit den Feldern Titel und isCompleted.“).
Lassen Sie den KI-Agenten das Schema für Sie erstellen.
﻿
Dies kann Zeit in den frühen Phasen Ihres React Native-Projekts sparen.
Daten lesen und schreiben mit REST API
Für die typische React Native-Entwicklung können Sie die native fetch API oder eine Drittanbieterbibliothek wie axios verwenden, um REST APIs zu verwalten. Unten finden Sie ein Beispiel mit cURL, das Sie für fetch, anpassen können:
POST (Todo erstellen):
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"title": "Buy groceries", "isCompleted": false}' \
  https://parseapi.back4app.com/classes/Todo
﻿
GET (Todos abrufen):
Bash
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  https://parseapi.back4app.com/classes/Todo
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APPLICATION_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  https://parseapi.back4app.com/classes/Todo
﻿
In deiner React Native-App kannst du dasselbe mit fetch:
JS
async function getTodos() {
  try {
    const response = await fetch('https://parseapi.back4app.com/classes/Todo', {
      method: 'GET',
      headers: {
        'X-Parse-Application-Id': 'YOUR_APPLICATION_ID',
        'X-Parse-REST-API-Key': 'YOUR_REST_API_KEY',
        'Content-Type': 'application/json',
      },
    });
    const data = await response.json();
    console.log('Fetched Todos:', data.results);
    return data.results;
  } catch (error) {
    console.error('Error fetching Todos:', error);
  }
}
async function getTodos() {
  try {
    const response = await fetch('https://parseapi.back4app.com/classes/Todo', {
      method: 'GET',
      headers: {
        'X-Parse-Application-Id': 'YOUR_APPLICATION_ID',
        'X-Parse-REST-API-Key': 'YOUR_REST_API_KEY',
        'Content-Type': 'application/json',
      },
    });
    const data = await response.json();
    console.log('Fetched Todos:', data.results);
    return data.results;
  } catch (error) {
    console.error('Error fetching Todos:', error);
  }
}
﻿
Daten lesen und schreiben mit der GraphQL-API
Wenn du GraphQL bevorzugst, bietet Back4App einen GraphQL-Endpunkt. Unten ist ein Beispiel für eine Mutation, um einen neuen Datensatz zu erstellen:
GraphQL
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
mutation {
  createTodo(input: {
    fields: {
      title: "Clean the house"
      isCompleted: false
    }
  }) {
    todo {
      objectId
      title
      isCompleted
    }
  }
}
﻿
Du kannst GraphQL-Abfragen mit einer Bibliothek wie apollo-client oder sogar einem einfachen fetch Aufruf ausführen:
JS
async function createTodoGraphQL() {
  const query = `
    mutation {
      createTodo(input: {
        fields: {
          title: "Study React Native"
          isCompleted: false
        }
      }) {
        todo {
          objectId
          title
        }
      }
    }
  `;

  try {
    const response = await fetch('https://parseapi.back4app.com/graphql', {
      method: 'POST',
      headers: {
        'X-Parse-Application-Id': 'YOUR_APPLICATION_ID',
        'X-Parse-REST-API-Key': 'YOUR_REST_API_KEY',
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ query }),
    });
    const result = await response.json();
    console.log('GraphQL Response:', result);
  } catch (error) {
    console.error('Error creating Todo with GraphQL:', error);
  }
}
async function createTodoGraphQL() {
  const query = `
    mutation {
      createTodo(input: {
        fields: {
          title: "Study React Native"
          isCompleted: false
        }
      }) {
        todo {
          objectId
          title
        }
      }
    }
  `;

  try {
    const response = await fetch('https://parseapi.back4app.com/graphql', {
      method: 'POST',
      headers: {
        'X-Parse-Application-Id': 'YOUR_APPLICATION_ID',
        'X-Parse-REST-API-Key': 'YOUR_REST_API_KEY',
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ query }),
    });
    const result = await response.json();
    console.log('GraphQL Response:', result);
  } catch (error) {
    console.error('Error creating Todo with GraphQL:', error);
  }
}
﻿
Arbeiten mit Live-Abfragen (optional)
Für Echtzeitdaten bietet Back4App Live-Abfragen, obwohl dies normalerweise das Parse SDK erfordert. Da wir uns in diesem Tutorial auf REST-Aufrufe konzentrieren, können Sie Live-Abfragen in den Servereinstellungen Ihrer App aktivieren, wenn Sie planen, sie später zu verwenden. Echtzeitdaten können Ihnen helfen, Benutzer in einer React Native-App sofort auf dem Laufenden zu halten. Für einen einfacheren Ansatz könnten Sie den Server in Ihren eigenen Intervallen abfragen oder auf Drittanbieter-Tools zurückgreifen.
Schritt 3 – Anwendung von Sicherheit mit ACLs und CLPs
Kurze Übersicht
Back4App sichert Ihr Backend mit ACLs (Zugriffskontrolllisten) und CLPs (Klassenebene-Berechtigungen). Diese ermöglichen es Ihnen, Daten sowohl auf Objekt- als auch auf Klassenebene zu schützen. Sie sind entscheidend für die Implementierung sicherer Benutzerberechtigungen in der Entwicklung mobiler Apps auf Produktionsniveau.
Schritt-für-Schritt
Klassenebene-Berechtigungen (CLPs):
Gehen Sie zum Abschnitt Datenbank Ihrer App, öffnen Sie eine beliebige Klasse und wechseln Sie zu „Sicherheit & Berechtigungen.“ Passen Sie die Lese-/Schreibberechtigungen für verschiedene Benutzerrollen oder den öffentlichen Zugriff an.
ACLs:
Sie können die Zugriffskontrolle pro Objekt anwenden, indem Sie _ACL-Felder in Ihren REST-Anfragen einfügen. Zum Beispiel:
Für weitere Details, schauen Sie sich die App-Sicherheitsrichtlinien an.
Schritt 4 – Schreiben von Cloud-Code-Funktionen
Warum Cloud-Code
Cloud-Code ermöglicht es Ihnen, serverseitige Skripte auf Back4App für Aufgaben wie Validierungen, Trigger und die Verarbeitung externer API-Aufrufe auszuführen. Es hilft Ihnen, Logik zu steuern, die vor dem Client verborgen bleiben sollte, und bietet eine bessere Sicherheit für Ihr React Native-Projekt.
Beispiel-Funktion
Unten finden Sie ein Beispiel, das Sie in Ihrer main.js auf der Serverseite schreiben würden. Sie können es von Ihrer React Native-App über REST aufrufen:
JS
// main.js

Parse.Cloud.define('generateGreeting', async (request) => {
  const { name } = request.params;
  if (!name) {
    throw 'Name parameter is missing!';
  }
  return `Hello, ${name}! Welcome to our React Native app.`;
});
// main.js

Parse.Cloud.define('generateGreeting', async (request) => {
  const { name } = request.params;
  if (!name) {
    throw 'Name parameter is missing!';
  }
  return `Hello, ${name}! Welcome to our React Native app.`;
});
﻿
Bereitstellung
Back4app CLI:
Installieren Sie die CLI, konfigurieren Sie Ihren Kontoschlüssel und führen Sie b4a deploy aus.
Dashboard:
Sie können auch zu Cloud Code > Funktionen, fügen Sie Ihren Code in main.js, ein und klicken Sie auf Bereitstellen.
﻿
Aufrufen Ihrer Funktion (über REST)
Verwenden Sie REST-APIs direkt aus Ihrer React Native-App:
JS
async function callCloudFunction(name) {
  try {
    const response = await fetch('https://parseapi.back4app.com/functions/generateGreeting', {
      method: 'POST',
      headers: {
        'X-Parse-Application-Id': 'YOUR_APP_ID',
        'X-Parse-REST-API-Key': 'YOUR_REST_API_KEY',
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ name }),
    });
    const data = await response.json();
    console.log('Greeting:', data.result);
  } catch (err) {
    console.error('Error calling Cloud Function:', err);
  }
}
async function callCloudFunction(name) {
  try {
    const response = await fetch('https://parseapi.back4app.com/functions/generateGreeting', {
      method: 'POST',
      headers: {
        'X-Parse-Application-Id': 'YOUR_APP_ID',
        'X-Parse-REST-API-Key': 'YOUR_REST_API_KEY',
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ name }),
    });
    const data = await response.json();
    console.log('Greeting:', data.result);
  } catch (err) {
    console.error('Error calling Cloud Function:', err);
  }
}
﻿
Diese Flexibilität macht Sie zu einem effizienteren Full-Stack-Entwickler, da Sie Geschäftslogik integrieren können, ohne sensible Details auf dem Client offenzulegen.
Schritt 5 – Konfigurieren der Authentifizierung
Benutzerauthentifizierung aktivieren oder einrichten
Back4App verwendet die Parse User-Klasse zur Verwaltung der Benutzerauthentifizierung. Selbst wenn Sie das Parse SDK in React Native nicht verwenden, können Sie sich registrieren, einloggen oder ausloggen, indem Sie direkte HTTP-Anfragen verwenden.
Benutzer registrieren (REST):
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
       "username": "alice",
       "password": "secretPassword",
       "email": "[email protected]"
     }' \
  https://parseapi.back4app.com/users
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
       "username": "alice",
       "password": "secretPassword",
       "email": "alice@example.com"
     }' \
  https://parseapi.back4app.com/users
﻿
Einloggen (REST):
Bash
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -G \
  --data-urlencode 'username=alice' \
  --data-urlencode 'password=secretPassword' \
  https://parseapi.back4app.com/login
curl -X GET \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -G \
  --data-urlencode 'username=alice' \
  --data-urlencode 'password=secretPassword' \
  https://parseapi.back4app.com/login
﻿
Diese Anfragen geben ein Sitzungstoken zurück, das Sie in Ihrer React Native-App speichern können, um Benutzersitzungen zu verwalten. Dies stellt sicher, dass jede Anfrage, die Sie stellen, autorisiert werden kann, und schafft mobile Erlebnisse, die sicher bleiben.
Soziale Anmeldung
Back4App unterstützt soziale Logins (Google, Facebook, Apple) über spezialisierte Abläufe. Sie müssen die Dokumentation zu sozialen Logins befolgen, um OAuth-Apps zu konfigurieren, und dann die entsprechenden Tokens an Back4App senden.
Schritt 6 – Umgang mit Dateispeicher
Einrichten des Dateispeichers
Back4App kann Dateien für Ihre React Native-App speichern. Sie können sie Objekten anhängen oder direkt hochladen. Da wir REST verwenden, finden Sie hier ein Beispiel für das Hochladen einer Datei (Base64-kodiert):
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: image/png" \
  --data-binary '@path_to_your_file.png' \
  https://parseapi.back4app.com/files/image.png
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: image/png" \
  --data-binary '@path_to_your_file.png' \
  https://parseapi.back4app.com/files/image.png
﻿
Die Antwort gibt eine URL zurück, die Sie in Ihrer Datenbank speichern können. Von Ihrer React Native-App aus können Sie dies mit fetch tun, indem Sie die Datei als Blob oder Formulardaten senden.
Sicherheitsüberlegungen
Um unbefugte Uploads zu verhindern, konfigurieren Sie die fileUpload-Optionen in Ihren Parse-Server-Einstellungen. Zum Beispiel könnten Sie Uploads nur von authentifizierten Benutzern zulassen. Dies stellt sicher, dass Dienste wie der Dateispeicher geschützt bleiben.
Schritt 7 – E-Mail-Verifizierung und Passwortzurücksetzung
Übersicht
Die Bestätigung des E-Mail-Besitzes ist entscheidend für die Implementierung sicherer Benutzerabläufe. Back4App bietet integrierte Tools für die E-Mail-Verifizierung und Passwortzurücksetzungen.
Back4App-Dashboard-Konfiguration
Öffnen Sie Ihre App-Einstellungen.
Aktivieren Sie die E-Mail-Verifizierung unter E-Mail-Einstellungen.
Passen Sie die Vorlagen an für Passwortzurücksetzungen und Verifizierungsnachrichten.
Code/Implementierung
Ein Benutzer, der sein Passwort vergessen hat, kann eine Zurücksetzanforderung auslösen:
Bash
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email": "[email protected]"}' \
  https://parseapi.back4app.com/requestPasswordReset
curl -X POST \
  -H "X-Parse-Application-Id: YOUR_APP_ID" \
  -H "X-Parse-REST-API-Key: YOUR_REST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email": "alice@example.com"}' \
  https://parseapi.back4app.com/requestPasswordReset
﻿
Back4App sendet eine E-Mail zur Passwortzurücksetzung an den Benutzer. Dieser Komfort erspart Ihnen die Einrichtung separater Mail-Server in Ihrer React Native-App.
Schritt 8 – Aufgaben mit Cloud-Jobs planen
Was Cloud-Jobs tun
Cloud-Jobs helfen Ihnen, wiederkehrende Aufgaben wie Datenbereinigung oder das Versenden täglicher Berichte zu automatisieren. Unten finden Sie ein Beispiel für einen Job in main.js:
JS
// main.js

Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);
  query.lessThan('createdAt', cutoff);

  try {
    const oldTodos = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
    return `Deleted ${oldTodos.length} old Todos.`;
  } catch (err) {
    throw new Error('Error during cleanup:' + err.message);
  }
});
// main.js

Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo');
  const query = new Parse.Query(Todo);
  const now = new Date();
  const THIRTY_DAYS = 30 * 24 * 60 * 60 * 1000;
  const cutoff = new Date(now - THIRTY_DAYS);
  query.lessThan('createdAt', cutoff);

  try {
    const oldTodos = await query.find({ useMasterKey: true });
    await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
    return `Deleted ${oldTodos.length} old Todos.`;
  } catch (err) {
    throw new Error('Error during cleanup:' + err.message);
  }
});
﻿
Stellen Sie diesen Code bereit, und gehen Sie dann zu Servereinstellungen > Hintergrundjobs, um ihn zu planen. Dies hält Ihre Daten auf Ihren iOS- und Android-Plattformen ohne manuelles Eingreifen aktuell.
Planung eines Cloud-Jobs
﻿
Schritt 9 – Integration von Webhooks
Definition
Webhooks ermöglichen es Ihrem Backend, externe Dienste zu benachrichtigen, wann immer ein Ereignis eintritt. Zum Beispiel könnten Sie Slack oder ein Zahlungs-Gateway benachrichtigen, wenn ein neues Todo erstellt wird.
Konfiguration
Gehen Sie zu Mehr > WebHooks in Ihrem Back4App-Dashboard.
Fügen Sie einen neuen Webhook hinzu der auf einen gewünschten externen Endpunkt zeigt.
Setzen Sie Trigger, um zu definieren, wann Änderungen Ihrer React Native-App-Daten den Webhook auslösen sollten.
Hinzufügen eines Webhooks
﻿
Sie können auch Webhooks innerhalb von Cloud-Code-Triggern codieren, die es Ihnen ermöglichen, HTTP-Anfragen zu senden oder mit Drittanbieter-APIs zu integrieren. Dies erweitert die Fähigkeiten Ihres Backends auf eine Vielzahl externer Dienste.
BeforeSave WebHook
﻿
Schritt 10 – Erkundung des Back4App Admin Panels
Wo man es findet
Das Back4App Admin Panel ist eine benutzerfreundliche Oberfläche für nicht-technische Personen zur Verwaltung von Daten. Es ist besonders nützlich für Produktinhaber, Kundenvertreter oder Supportmitarbeiter, die direkten Zugang zu Ihrem Datenmodell benötigen.
Funktionen
Admin-App aktivieren in Ihrem App-Dashboard > Mehr > Admin-App.
Einen Admin-Benutzer erstellen (Benutzername/Passwort).
Wählen Sie eine Subdomain für schnellen, codefreien Datenbankzugriff.
Admin-App aktivieren
﻿
Sobald Sie angemeldet sind, können Ihre Benutzer oder Ihr Team Datensätze anzeigen, bearbeiten oder löschen, ohne Code schreiben zu müssen. Dieser Ansatz unterstützt eine schnellere Datenverwaltung und Zusammenarbeit.
Fazit
In diesem Leitfaden haben Sie gelernt wie man ein Backend für React Native Anwendungen mit Back4App erstellt. Dazu gehörte:
Ein sicheres Backend zu erstellen und plattformübergreifende Kompatibilität für Ihre React Native-App zu implementieren.
Datenmanagement mit REST- und GraphQL-APIs einzurichten.
ACLs und CLPs zu konfigurieren, um sensible Daten zu schützen.
Cloud Code für serverseitige Logik zu schreiben.
Benutzerauthentifizierung und E-Mail-Verifizierung zu handhaben.
Dateispeicherung mit direkten Uploads zu verwalten.
Hintergrundaufgaben mit Cloud Jobs zu planen.
Webhooks zu verwenden, um externe Dienste zu integrieren.
Das Back4App Admin Panel zu erkunden, um die Datenbankverwaltung zu erleichtern.
Mit diesen Tools und Funktionen kann Ihr React Native-Projekt zu einer zuverlässigen und skalierbaren Full-Stack-Lösung wachsen. Sie sind jetzt in der Lage, Echtzeitdaten, Benutzersicherheit und andere wichtige Aspekte mobiler Anwendungen zu verwalten. Erkunden Sie weiterhin die Back4App-Dokumentation um Ihre Fähigkeiten zu verfeinern und leistungsstarke mobile Erlebnisse auf iOS- und Android-Plattformen zu schaffen.
Nächste Schritte
Härten Sie Ihre React Native-App mit fortschrittlicher Sicherheit und rollenbasiertem Zugriffskontrolle.
Experimentieren Sie mit Echtzeit-Updates mithilfe von Live-Abfragen für Echtzeitanwendungen (falls erforderlich).
Integrieren Sie externe APIs und Dienste, einschließlich Zahlungs-Gateways oder sozialer Logins.
Verbessern Sie die Leistung durch Caching oder Optimierung von Cloud-Funktionen.
Tauchen Sie tiefer ein in die offiziellen Dokumente von Back4App um zusätzliche Funktionen freizuschalten.
﻿
Aktualisiert 23 Jan 2025
Hat Ihnen diese Seite geholfen?
Wie man ein Backend für Xamarin aufbaut?
ALS NÄCHSTES
Wie man ein Backend für Objective-C erstellt?