Wie erstellt man ein Backend für eine mobile App?

In diesem Artikel erfahren Sie, was ein Backend für eine mobile App ist und was Sie wissen müssen, um Ihr Backend zu erstellen.

Wir werden die Unterschiede zwischen einem Backend und einem Frontend, verschiedene Backend-Typen, mobile Backend-Funktionen und die Kosten für die Entwicklung eines Backends kennenlernen.

Schließlich werden wir lernen, wie man ein Backend für eine einfache mobile Anwendung auf Back4app erstellt – einem der besten MBaaS-Anbieter.

Unterschiede zwischen einem Frontend und einem Backend

Die Begriffe “Frontend” und “Backend” beziehen sich auf die Trennung zwischen der Präsentationsschicht und der Datenzugriffsschicht.

Der einfachste Weg, ihre Unterschiede zu verstehen, ist, sich einen Eisberg vorzustellen. Das Frontend befindet sich oberhalb des Wasserspiegels und ist alles, was der Benutzer sehen und mit dem er interagieren kann. Das Backend hingegen ist der Teil des Eisbergs, der unter Wasser liegt. Es ist die zugrunde liegende Logik, die das Geschäft antreibt.

Frontend

Ein Frontend ist die grafische Benutzeroberfläche einer Website, einer mobilen Anwendung oder einer anderen Art von Client, mit der ein Benutzer interagieren kann. Das Frontend umfasst alle visuellen Aspekte einer Anwendung, einschließlich des Designs, der Menüs, Texte, Bilder, Videos und so weiter. Bei den meisten Projekten macht es etwa 20 % des Gesamtaufwands aus und ist nicht repetitiv.

Frontend-Entwickler müssen sich darum kümmern:

• Reaktionsfähiges Design
• Leistung der App
• Browserübergreifende Kompatibilität
• Bedenken hinsichtlich der Zugänglichkeit
• SEO-Optimierung

Web-Frontends werden normalerweise mit Tools wie HTML, CSS, JavaScript und WebAssembly implementiert. Native Android-Apps werden in Java/Kotlin geschrieben, während native iOS-Apps Objective-C und Swift verwenden.

In den letzten Jahren haben viele Frontend-Entwickler Tools wie React Native, Vue und Svelte Native adaptiert, um den Entwicklungsprozess weiter zu vereinfachen und die gleiche Codebasis auf verschiedenen Plattformen zum Laufen zu bringen.

Frontends können bei Diensten wie Google Play, App Store, Vercel, Netlify “eingesetzt” werden.

Backend

Unter Backend- oder Server-seitiger Entwicklung versteht man die Entwicklung der Datenzugriffsschicht. Das Backend ist die Verbindung zwischen der Datenbank und dem Frontend. Die meisten Backends bieten eine Anwendungsschichtschnittstelle (API), die ein Frontend zum Abrufen und Speichern von Daten verwenden kann.

Die Daten werden in der Regel im JSON- oder GraphQL-Format ausgetauscht. Ein Backend macht in der Regel etwa 80 % der Arbeit aus und ist repetitiv. Zum Beispiel erfordert fast jedes Projekt Authentifizierung, Autorisierung, Datenbankverwaltung usw.

Backend-Entwickler sind verantwortlich für:

• Verwaltung von Datenbanken
• Geschäftslogik der Anwendung
• Skalierbarkeit, hohe Verfügbarkeit
• Sicherheitsbedenken und Backups

Backend-Entwickler arbeiten normalerweise mit Programmiersprachen wie Python, JavaScript (Node.js), Ruby, C#, Java und Go. Zum Zeitpunkt der Erstellung dieses Artikels ist die beliebteste Backend-Architektur Model-View-Controller (MVC), die von vielen Web-Frameworks wie Django und Laravel übernommen wurde.

Die wichtigste Komponente eines Backends ist seine Datenbank. Es gibt verschiedene Arten von Datenbanken, die wir in drei allgemeine Kategorien einteilen können:

• SQL-Datenbanken
• NoSQL-Datenbanken
• Multi-Paradigma-Datenbanken

Sie haben alle ihre Vor- und Nachteile, die bei der Planung eines Projekts berücksichtigt werden sollten.

Ein Backend kann je nach gewünschter Abstraktionsebene auf verschiedenen Plattformen bereitgestellt werden. Sie können zum Beispiel Ihren eigenen Server, IaaS (AWS, GCE, Azure), PaaS (Heroku, Digital Ocean App Service) oder BaaS (Back4app, Firebase, AWS Amplify) verwenden.

Lesen Sie weiter, um mehr über die Backend-Entwicklung von mobilen Anwendungen zu erfahren.

Was ist ein Backend für eine mobile Anwendung?

Ein Backend für eine mobile Anwendung ist der Teil der Anwendung, der nicht auf dem Gerät selbst, sondern auf einem Server läuft. Das Backend bietet die Funktionen, die die App benötigt, um Daten zu speichern und zu verwalten, Benutzer zu authentifizieren, Daten zu verarbeiten und zu analysieren und mit anderen Systemen oder Diensten zu kommunizieren.

Ein Backend kann viele Formen annehmen, z. B. einen Server, der auf einem Cloud-Dienst läuft, eine Datenbank oder eine API. Es stellt die notwendige Infrastruktur und die Tools bereit, die die App benötigt, um ordnungsgemäß zu funktionieren, und ermöglicht es der App, ein reichhaltiges und ansprechendes Benutzererlebnis zu bieten.

Welche Funktionen bietet ein mobiles Backend?

Ein Backend für eine mobile Anwendung bietet in der Regel die folgenden Funktionen:

• Speicherung und Verwaltung von Daten
• Verarbeitung und Analyse von Daten
• Authentifizierung und Autorisierung
• Synchronisierung zwischen mehreren Geräten
• Fähigkeit zur Integration mit anderen Systemen und Diensten
• Verwaltung serverseitiger Aufgaben
• Analyse und Überwachung
• Push-Benachrichtigungen

Braucht eine mobile App ein Backend?

Kurze Antwort: Wenn Ihre Anwendung lokal (ohne Internetverbindung) funktioniert, brauchen Sie normalerweise kein Backend, was aber nicht bedeutet, dass Ihre Anwendung nicht von einem Backend profitieren kann.

Um diese Antwort besser zu verstehen, werfen wir einen Blick auf einige der Apps, die wir im täglichen Leben verwenden.

Anwendungen, die kein Backend benötigen:

• Taschenrechner
• Kalender und Uhr
• Kamera und Galerie
• Sprachaufzeichnungsgerät
• Einzelspielerspiele

Anwendungen, die ein Backend benötigen:

• E-Commerce-Anwendungen – ein Backend ist erforderlich, um den Bestand zu verfolgen, Bestellungen zu bearbeiten usw.
• Verkehrsanwendungen – ein Backend ermöglicht die Bearbeitung von Fahrkarten, Informationen über Verspätungen usw.
• Messaging-Apps – ein Backend wird verwendet, um Nachrichten von einem Gerät zum anderen zu übertragen
• Wetter-Apps – ein Backend ist erforderlich, um aktuelle Wetterinformationen abzurufen

Überlegen wir nun, wie ein Backend die oben genannten Anwendungen verbessern könnte:

• Rechner – könnte ein Backend verwenden, um komplexe Berechnungen auf einen entfernten Server auszulagern
• Kalender und Uhr – können Ereignisse in einer Datenbank speichern und zwischen Geräten synchronisieren
• Kamera – könnte einen Backend-Dienst zur Korrektur von Verzerrungen, Beleuchtung usw. nutzen.
• Sprachaufzeichnungsgerät – könnte einen Backend-Dienst zur Rauschunterdrückung nutzen
• Einzelspielerspiele – könnten den Punktestand der Benutzer in einer Datenbank speichern und eine Rangliste anzeigen

Aufgrund der großen Vorteile, die Backends zu bieten haben, verfügt fast jede mobile Anwendung über ein Backend. Wenn auch nicht zum Speichern von Daten, ermöglicht das Backend mobilen Anwendungen, Analysen zu sammeln, Push-Benachrichtigungen zu senden, Anwendungen zu überwachen, Absturzberichte zu sammeln und vieles mehr. Wenn Sie erfolgreich sein wollen, werden Sie höchstwahrscheinlich ein Backend benötigen.

Was sind die Backend-Typen?

Je nach Art Ihrer Anwendung können Sie aus mehreren Backend-Typen wählen. Im Allgemeinen lassen sie sich je nach Abstraktionsgrad in drei Gruppen einteilen:

1. Software as a Service (SaaS) oder Dienste von Drittanbietern
2. Mobiles Backend als Dienstleistung (MBaaS)
3. Benutzerdefinierte Backends

Werfen wir einen Blick auf jeden einzelnen von ihnen.

Software as a Service (SaaS) oder Dienste von Drittanbietern

Software as a Service (SaaS) ist ein Softwarebereitstellungsmodell, bei dem eine Softwareanwendung von einem Drittanbieter gehostet und den Kunden über das Internet zur Verfügung gestellt wird.

Bei SaaS-Lösungen müssen die Kunden in der Regel eine monatliche oder jährliche Abonnementgebühr entrichten. Dieser Backend-Typ ist am einfachsten zu verwenden und ermöglicht es Ihnen, Ihr Backend mit wenigen Klicks einzurichten und in Betrieb zu nehmen.

Der Nachteil dieses Backend-Typs ist, dass Sie höchstwahrscheinlich keine SaaS-Lösung finden werden, die alle Anforderungen Ihres Projekts erfüllt. Um ein realistisches Backend zu erstellen, müssen Sie wahrscheinlich mehrere SaaS-Lösungen kombinieren.

Ein paar Beispiele für SaaS sind:

• WordPress (Inhaltsverwaltungssystem)
• Mailchimp (Verwaltungssoftware und E-Mail-Marketing)
• Salesforce (Software zur Verwaltung von Kundenbeziehungen)
• Shopify (Plattform für den elektronischen Handel)
• Dropbox (Datei-Hosting)

Mobiles Backend als Dienstleistung (MBaaS)

Backend as a Service (BaaS) ist eine Plattform, die die Backend-Seite der Entwicklung automatisiert und sich um die Cloud-Infrastruktur kümmert.

Darüber hinaus bietet es Funktionen wie Benutzerverwaltung, E-Mail-Benachrichtigungen, Push-Benachrichtigungen, Cloud-Code-Funktionen, Integrationen in soziale Medien, Dateispeicherung und Zahlungen.

So können sich die Entwickler auf das Kerngeschäft und die Entwicklung des Frontends konzentrieren, ohne sich um das zugrunde liegende Backend und die Infrastruktur kümmern zu müssen. Das Frontend wird in der Regel über spezielle APIs und SDKs entwickelt, die vom BaaS-Anbieter angeboten werden. Dadurch sind die Anwendungen weniger komplex und leichter zu pflegen.

Zu den Vorteilen eines Backend as a Service gehören eine schnellere Entwicklungsgeschwindigkeit, niedrigere Entwicklungskosten und die Konzentration auf das Kerngeschäft.

Einige Beispiele für BaaS sind:

• Back4app
• Firebase
• AWS Amplify
• Apple Cloudkit

Möchten Sie mehr über BaaS und MBaas erfahren? Werfen Sie einen Blick auf Was ist BaaS?

Benutzerdefiniertes Backend

Ein benutzerdefiniertes Backend ist die leistungsfähigste und flexibelste Option. Es bietet Ihnen die volle Kontrolle und ermöglicht Ihnen die Implementierung von Funktionen, die mit einer SaaS- oder MBaaS-Lösung nicht möglich sind.

Der größte Nachteil sind die Kosten und der Zeitaufwand für die Erstellung. Bei diesem Ansatz sind Sie auch voll für die Leistung und Sicherheit Ihres Backends verantwortlich.

Die Erstellung eines benutzerdefinierten Backends dauert in der Regel Monate und erfordert einen erfahrenen Backend-Entwickler oder sogar ein Team von Backend-Entwicklern.

Beliebte Frameworks für die Erstellung benutzerdefinierter Backends:

• Django
• Laravel
• Express.js
• Ruby on Rails
• Spring Boot

Weitere Informationen über Backend-Frameworks finden Sie unter Top 10 Backend-Frameworks.

Wie viel kostet die Erstellung eines Backends für eine mobile Anwendung?

Es gibt keine einfache Formel, um die Kosten für ein Backend einer mobilen App zu berechnen. Die Kosten variieren je nach Komplexität der App, der Anzahl der Funktionen, ihrer Skalierbarkeit, Leistung usw.

SaaS-Kosten

SaaS ist in der Regel die günstigste Option, für die Sie sich entscheiden können. SaaS-Produkte folgen in der Regel einem unkomplizierten Preismodell mit monatlichen oder jährlichen Abonnementgebühren. Einige SaaS-Anbieter bieten auch verschiedene Preisstufen an, die von der Größe Ihres Unternehmens abhängen.

MBaaS-Kosten

Die Erstellung eines Backends mit MBaaS ist im Vergleich zu einem benutzerdefinierten Backend wirklich günstig. Sie können die Entwicklungskosten erheblich senken und müssen sich nicht um die Infrastruktur oder die Einstellung eines Teams von spezialisierten Backend-Ingenieuren kümmern. Das spart Ihnen eine Menge Geld!

Bei den meisten MBaaS-Anbietern gibt es verschiedene Preisstufen, die von der Größe Ihrer Anwendung abhängen. Wenn Sie MBaaS nutzen, können Sie mit Kosten zwischen 15 und 500 US-Dollar pro Monat rechnen.

Benutzerdefinierte Backend-Kosten

Die kundenspezifische Backend-Entwicklung ist die teuerste Option. Wenn Sie diese Option wählen, müssen Sie ein Team von qualifizierten Entwicklern zusammenstellen und sich um die Infrastruktur Ihres Backends kümmern.

Die Preise für die Erstellung eines benutzerdefinierten Backends bewegen sich in der Regel zwischen einigen Tausend Dollar und Zehntausenden von Dollar, je nach den Anforderungen des Projekts.

Da die Implementierung eines benutzerdefinierten Backends eine schwierige Aufgabe ist, beauftragen Unternehmen in der Regel Unternehmen, die auf Softwareentwicklung spezialisiert sind.

Wie erstellt man ein Backend für eine mobile Anwendung mit MBaaS?

In diesem Abschnitt des Tutorials sehen wir uns an, wie man ein Backend für eine mobile App mit Back4app entwickelt.

Was ist Back4app?

Back4app ist eine der besten Open-Source-Backend-as-a-Service-Lösungen (BaaS) auf dem Markt. Sie bietet ihren Nutzern eine breite Palette von Funktionen und Vorteilen, die es Entwicklern ermöglichen, schnell Web- und Mobilanwendungen zu erstellen.

Durch den Einsatz von Back4app können Sie sich auf Ihr Kerngeschäft konzentrieren, anstatt sich um das Backend oder die zugrunde liegende Infrastruktur zu kümmern.

Die Lösung verfügt über ein funktionsreiches und einfach zu bedienendes Dashboard und eine Befehlszeilenschnittstelle (CLI). Sie bieten auch SDKs für alle Ihre Lieblings-Tools wie Flutter, React Native, Node.js, Angular, Android, iOS & mehr!

Zu den wichtigsten Funktionen von Back4app gehören:

• Tabellenkalkulationsähnliche Datenbank
• REST- und GraphQL-APIs
• Live-Abfragen
• Authentifizierung (einschließlich sozialer Authentifizierung)
• Skalierbares Hosting
• Push- und E-Mail-Benachrichtigungen

Weitere Informationen zu den Funktionen finden Sie unter Back4app-Funktionen.

Back4app verfolgt ein einfaches und unkompliziertes Preismodell, das für Apps jeder Größe geeignet ist. Sie bieten einen großzügigen kostenlosen Plan (keine Kreditkarte erforderlich), der sich hervorragend für Prototypen und zum Testen der Plattform eignet. Es umfasst:

• 25k Anfragen
• 250 MB Datenspeicher
• 1 GB Übertragung
• 1 GB Dateispeicher

Weitere Informationen über die Preise von Back4app finden Sie auf der Seite Preise.

Projekt-Einführung

Wir werden ein Backend für eine einfache Nachrichten-App bauen. Die App wird es Redakteuren ermöglichen, Artikel zu erstellen, zu aktualisieren und zu löschen. Um die Verwaltung so einfach wie möglich zu gestalten, werden wir die Admin App von Back4app aktivieren.

Wir kümmern uns um die Sicherheit des Backends und zeigen, wie man die REST-API des Backends nutzt. Das Backend wird mit einer minimalen Menge an Code erstellt.

Voraussetzungen:

• Grundlegendes Verständnis von Backend as a Service (BaaS)
• Grundkenntnisse über Datenbanken (und Beziehungen zwischen Modellen)
• Grundlegendes Verständnis von HTTP-Anfragen und -Antworten
• Verstehen der JSON-Syntax

Zielsetzungen:

Am Ende dieses Tutorials werden Sie in der Lage sein:

• Erstellen und Bereitstellen eines einfachen Backends auf Back4app
• Ihre eigene Datenbank strukturieren können
• Verstehen der Grundlagen der Parse Platform Security
• Wissen, wie man CRUD-Operationen über die REST-API durchführt

App erstellen

Für die folgenden Schritte benötigen Sie ein Back4app-Konto. Wenn Sie bereits ein Konto haben, loggen Sie sich ein, ansonsten melden Sie sich für das kostenlose Konto an.

Um mit Back4app zu arbeiten, müssen wir zunächst eine App erstellen. Wenn Sie sich in Ihrem Dashboard anmelden, sehen Sie die Liste Ihrer Apps. Klicken Sie auf “Build a new app”, um eine neue App zu erstellen.

Geben Sie ihm einen eigenen Namen und klicken Sie dann auf “Weiter”.

Back4app nimmt sich einige Augenblicke Zeit, um alles vorzubereiten, was für Ihre App erforderlich ist, wie z. B. Datenbank, Anwendungsschicht, Skalierung, Backups und Sicherheit.

Sobald Ihre Anwendung fertig ist, werden Sie zum Dashboard Ihrer Anwendung weitergeleitet.

Datenbank

In diesem Abschnitt des Tutorials werden wir alle erforderlichen Datenbankmodelle erstellen.

Wie in der Projekteinführung erwähnt, werden wir eine einfache Nachrichten-App erstellen. Unsere Datenbank wird sich aus den folgenden Modellen zusammensetzen:

• Artikel steht für einen Nachrichtenartikel.
• ArticleCategory steht für eine Artikelkategorie (z. B. Sport, Unterhaltung). Ein Artikel kann nur zu einer Kategorie gehören.
• ArticleTag steht für einen Artikel-Hashtag (z. B. Kosmetik, Gesundheit, Schönheit). Ein Artikel kann mehrere Hashtags haben.

Diese Datenbankstruktur wird es uns später ermöglichen, die Artikel auf der Grundlage von Kategorien oder Tags zu filtern. Zeichnen wir nun ein Entity-Relationship-Diagramm (ERD), um die Beziehungen zwischen den Modellen besser zu verstehen:

Lassen Sie uns nun die Modelle erstellen.

Beginnen Sie mit der Erstellung des Modells ” ArticleCategory". Klicken Sie oben links auf dem Bildschirm auf “Klasse erstellen”, nennen Sie sie ArticleCategory und fügen Sie die folgenden Felder hinzu:

+-----------------------------+-------------+---------------+----------+
| Data type                   | Name        | Default value | Required |
+-----------------------------+-------------+---------------+----------+
| String                      | name        | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+
| String                      | description | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| Pointer -> User             | author      | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+

Als Nächstes erstellen Sie eine weitere Klasse mit dem Namen ArticleTag mit den folgenden Angaben:

+-----------------------------+-------------+---------------+----------+
| Data type                   | Name        | Default value | Required |
+-----------------------------+-------------+---------------+----------+
| String                      | name        | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+
| Pointer -> User             | author      | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+

Erstellen Sie schließlich eine weitere Klasse mit dem Namen Article mit den folgenden Feldern:

+-----------------------------+-------------+---------------+----------+
| Data type                   | Name        | Default value | Required |
+-----------------------------+-------------+---------------+----------+
| String                      | title       | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+
| String                      | description | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| String                      | content     | <leave blank> | yes      |
+-----------------------------+-------------+--------------+-----------+
| Pointer -> ArticleCategory  | category    | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| Relation -> ArticleTag      | tags        | <leave blank> | no       |
+-----------------------------+-------------+---------------+----------+
| Pointer -> User             | author      | <leave blank> | yes      |
+-----------------------------+-------------+---------------+----------+

Das war’s mit der Datenbankarchitektur. Fügen wir nun einige Beispieldaten hinzu.

Um die Sache ein wenig zu vereinfachen, habe ich einige Daten generiert, die Sie importieren können. Um einen Datensatz zu importieren, wählen Sie die Klasse auf der linken Seite des Bildschirms aus und klicken dann auf die drei Punkte auf der rechten Seite des Bildschirms. Wählen Sie “Importieren” > “Klassendaten” und wählen Sie die entsprechende Datei.

Um die JSON-Datensätze herunterzuladen, navigieren Sie zum back4app-mobile GitHub Repo, klicken Sie auf “Code” und dann auf “Download ZIP”.

Importieren Sie die JSON-Dateien in der folgenden Reihenfolge:

1. Benutzer
2. ArtikelKategorie
3. ArtikelTag
4. Artikel

Verwaltungsbereich

Um die Verwaltung ein wenig zu vereinfachen, aktivieren wir die Admin App. Die Admin App ist ein Webbrowser-basiertes Tool zur Verwaltung der App-Daten über eine nichttechnische Benutzeroberfläche.

Navigieren Sie zu Ihrem App-Dashboard, klicken Sie auf “Mehr” > “Admin App” und dann auf die Schaltfläche “Admin App aktivieren”.

Wählen Sie einen Benutzernamen und ein Passwort. Ich werde es nehmen:

Username: admin
Password: complexpassword123

Wählen Sie dann einen Domänennamen, den Sie für den Zugang zu Ihrem Verwaltungsbereich verwenden möchten. Ich wähle:

mobile-backend.admin.back4app.com

Gut, Sie können sich jetzt bei Ihrem Admin-Dashboard auf der ausgewählten Domain anmelden.

Um mehr über Back4app Admin App zu erfahren, werfen Sie einen Blick in die offiziellen Dokumente.

Absicherung der App

Um unsere App sicher zu machen, müssen wir Folgendes tun:

1. Clients das Erstellen von Datenbankklassen untersagen.
2. Ändern Sie die Berechtigungen auf Klassenebene (CLPs) des Benutzermodells.
3. Ändern Sie die CLPs für jedes von uns erstellte Modell.

Erstellung von Client-Klassen nicht zulassen

Um die Erstellung von Client-Klassen zu deaktivieren, navigieren Sie zu “App Settings” > “Server Settings” > “Core Settings” > “Edit”, scrollen Sie bis zum Ende der Seite und deaktivieren Sie “Allow Client Class Creation”.

Ändern der Benutzermodell-CLPs

Wählen Sie Ihr Benutzermodell auf der Registerkarte “Datenbank” aus und klicken Sie auf die drei Punkte auf der rechten Seite des Bildschirms > “Sicherheit” > “Berechtigungen für Klassenstufen”. Klicken Sie dann auf das Zahnradsymbol und ändern Sie es auf “Erweitert”. Deaktivieren Sie alles außer ” Abrufen" und ” Erstellen" wie folgt:

Ändern Sie CLPs für jedes von uns erstellte Modell

Machen Sie etwas Ähnliches für alle Ihre benutzerdefinierten Modelle(Artikel, ArtikelKategorie und ArtikelTag). Diesmal deaktivieren Sie alles außer Lesen und Suchen für die Gruppe "Public" wie folgt:

Auf diese Weise können nicht authentifizierte Benutzer die Artikel nur finden und lesen.

Weitere Informationen zum Thema Sicherheit finden Sie unter Parse Security.

API-Tests

In diesem Abschnitt des Tutorials werden wir unsere API mithilfe der integrierten API-Konsole testen.

Um die REST-API-Konsole zu öffnen, navigieren Sie zum Dashboard Ihrer App. Wählen Sie “Konsole” im Abschnitt “API” und dann “REST”.

Aufgrund unserer ACL/CLPs müssen Sie das Häkchen bei “Use Master Key?” setzen, damit die Anfragen erfolgreich sind.

abrufen.

Objekte können mit dem Anfragetyp GET abgerufen werden. Verwenden Sie für den Endpunkt classes/, z. B. classes/Article, und klicken Sie auf die Schaltfläche “Send Query” am unteren Rand der Seite.

Die Antwort wird in etwa so aussehen:

{
    "results": [
                {
            "objectId": "oRwkdx7KgX",
            "title": "Voting 2022 has ended!",
            "description": "The voting for year 2022 has ended, the new major is...",
            "content": "Lorem ipsum dolor sit amet...",
            "category": {
                "__type": "Pointer",
                "className": "ArticleCategory",
                "objectId": "FYxzrBlCBC"
            },
            "author": {
                "__type": "Pointer",
                "className": "_User",
                "objectId": "UZ76K07znv"
            },
            "createdAt": "2022-12-13T09:09:04.845Z",
            "updatedAt": "2022-12-13T09:09:13.297Z",
            "tags": {
                "__type": "Relation",
                "className": "ArticleTag"
            }
        },
        ... more results ...
    ]
}

Wenn Sie ein bestimmtes Ergebnis abrufen oder die Abfrage filtern möchten, sehen Sie sich die Dokumentation an.

erstellen.

Um eine Modellinstanz zu erstellen, wählen Sie die POST-Anfrage und übermitteln Sie sie an classes/, z. B. classes/Article. Bei POST-Anfragen müssen Sie Abfrageparameter angeben. Zum Beispiel:

{
   "title": "Another article",
   "content": "This is another test article added via the API",
   "category": {
      "__type": "Pointer",
      "className" :"ArticleCategory",
      "objectId": "pPGdxPAxQA"
   },
   "author": {
      "__type": "Pointer",
      "className": "_User",
      "objectId": "LFAf3yD8w0"
   }
}

Antwort:

{
    "objectId": "yAbmJ0sRZT",
    "createdAt": "2022-12-12T17:18:32.922Z"
}

Update

Um ein Modell zu aktualisieren, wählen Sie den Anfragetyp PUT und senden ihn an classes//