Schnellstarter
Wie man ein Backend für Android erstellt?

46min
Einführung
In diesem Tutorial lernen Sie, wie Sie ein vollständiges Backend für eine Android (Java) Anwendung mit Back4App erstellen.
Wir werden die Integration wesentlicher Back4App-Funktionen durchgehen – wie Datenbankverwaltung, Cloud-Code-Funktionen, REST- und GraphQL-APIs, Benutzerauthentifizierung und Echtzeitanfragen (Live Queries) – um ein sicheres, skalierbares und robustes Backend zu erstellen, das nahtlos mit Ihrem Android-Client kommuniziert.
Sie werden auch sehen, wie die schnelle Einrichtung und die intuitive Umgebung von Back4App die Zeit und den Aufwand im Vergleich zur manuellen Konfiguration von Servern und Datenbanken drastisch reduzieren können.
Auf dem Weg dorthin werden Sie praktische Erfahrungen mit wichtigen Funktionen sammeln, einschließlich fortschrittlicher Sicherheitsfunktionen, der Planung von Aufgaben mit Cloud-Jobs und der Einrichtung von Webhooks für externe Integrationen.
Am Ende dieses Tutorials sind Sie gut vorbereitet, um dieses grundlegende Setup in eine produktionsbereite Anwendung zu erweitern oder bei Bedarf benutzerdefinierte Logik und Drittanbieter-APIs einfach zu integrieren.
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, können Sie eines kostenlos erstellen. Befolgen Sie die obige Anleitung, um Ihr Projekt vorzubereiten.
Grundlegende Android (Java) Entwicklungsumgebung
Sie können dies mit Android Studio oder einem ähnlichen Tool einrichten. Stellen Sie sicher, dass Sie das neueste Android SDK installiert haben.
Java (Version 8 oder höher)
Sie benötigen Java, um Ihr Android-Projekt zu kompilieren und auszuführen.
Vertrautheit mit Java und grundlegenden Android-Konzepten
Android-Entwicklerdokumentation.
Wenn Sie neu in Android sind, lesen Sie die offiziellen Dokumente oder ein Anfänger-Tutorial, bevor Sie beginnen.
Stellen Sie sicher, dass Sie alle diese Voraussetzungen erfüllt haben, bevor Sie beginnen. Ihr Back4App-Projekt eingerichtet und Ihre lokale Android-Umgebung bereit zu haben, wird Ihnen helfen, leichter folgen zu können.
Schritt 1 – Einrichtung des Back4App-Projekts
Ein neues Projekt erstellen
Der erste Schritt beim Erstellen Ihres Android-Backends auf Back4App besteht darin, ein neues Projekt zu erstellen. Wenn Sie noch keines erstellt haben, folgen Sie diesen Schritten:
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. „Android-Backend-Tutorial“).
﻿
Sobald das Projekt erstellt ist, wird es in Ihrem Back4App-Dashboard aufgeführt. Dieses Projekt wird die Grundlage für alle Backend-Konfigurationen sein, die in diesem Tutorial besprochen werden.
Verbinden Sie das Parse SDK
Back4App basiert auf der Parse-Plattform, um Ihre Daten zu verwalten, Echtzeitfunktionen bereitzustellen, die Benutzerauthentifizierung zu handhaben und mehr. Die Verbindung Ihrer Android-Anwendung mit Back4App umfasst die Installation des Parse Android SDK und die Initialisierung mit den Anmeldeinformationen aus Ihrem Back4App-Dashboard.
Rufen Sie Ihre Parse-Schlüssel ab:
Navigieren Sie in Ihrem Back4App-Dashboard zu den „App-Einstellungen“ oder dem Abschnitt „Sicherheit & Schlüssel“, um Ihre Anwendungs-ID und Client-Schlüssel (oder JavaScript-Schlüssel, falls angegeben) zu finden. Sie finden auch die Parse-Server-URL (oft im Format https://parseapi.back4app.com).
﻿
Installieren Sie das Parse SDK in Ihrem Android-Projekt, indem Sie diese Zeilen zu Ihrem module-level build.gradle:
Text
dependencies {
    implementation "com.github.parse-community.Parse-SDK-Android:parse:latest.version.here"
}
dependencies {
    implementation "com.github.parse-community.Parse-SDK-Android:parse:latest.version.here"
}
﻿
Wenn Sie das Jitpack-Repository in Ihrem root build.gradle:
Text
allprojects {
    repositories {
        ...
        maven { url "https://jitpack.io" }
    }
}
allprojects {
    repositories {
        ...
        maven { url "https://jitpack.io" }
    }
}
﻿
Initialisieren Sie Parse in Ihrer Android-Anwendung:
Erstellen Sie eine benutzerdefinierte Application-Klasse (z. B. App.java) und konfigurieren Sie die AndroidManifest.xml:
Java
package com.example.app;

import android.app.Application;
import com.parse.Parse;

public class App extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        Parse.initialize(new Parse.Configuration.Builder(this)
                .applicationId("YOUR_APP_ID")       // from Back4App
                .clientKey("YOUR_CLIENT_KEY")       // from Back4App
                .server("https://parseapi.back4app.com/")
                .build()
        );
    }
}
package com.example.app;

import android.app.Application;
import com.parse.Parse;

public class App extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        Parse.initialize(new Parse.Configuration.Builder(this)
                .applicationId("YOUR_APP_ID")       // from Back4App
                .clientKey("YOUR_CLIENT_KEY")       // from Back4App
                .server("https://parseapi.back4app.com/")
                .build()
        );
    }
}
﻿
Fügen Sie dann diese benutzerdefinierte Application-Klasse in Ihre AndroidManifest.xml:
XML
<?xml version="1.0" encoding="utf-8"?>
<manifest ... >
    <application
        android:name=".App"
        ... >
        ...
    </application>
</manifest>
<?xml version="1.0" encoding="utf-8"?>
<manifest ... >
    <application
        android:name=".App"
        ... >
        ...
    </application>
</manifest>
﻿
Durch das Abschließen dieses Schrittes haben Sie eine sichere Verbindung zwischen Ihrem Android-Frontend und dem Back4App-Backend hergestellt. Alle Anfragen und Datenübertragungen werden sicher über dieses SDK geleitet, wodurch die Komplexität manueller REST- oder GraphQL-Aufrufe verringert wird (obwohl Sie diese bei Bedarf weiterhin verwenden können).
Schritt 2 – Datenbank einrichten
Daten speichern und abfragen
Mit Ihrem Back4App-Projekt, das eingerichtet und das Parse SDK in Ihre Android-App integriert ist, können Sie jetzt beginnen, Daten zu speichern und abzurufen. Eine typische Möglichkeit, einen Datensatz zu erstellen und zu speichern, besteht darin, die ParseObject-Klasse zu verwenden:
Java
ParseObject gameScore = new ParseObject("GameScore");
gameScore.put("score", 1337);
gameScore.put("playerName", "Sean Plott");
gameScore.put("cheatMode", false);
gameScore.saveInBackground(e -> {
    if (e == null) {
        // Success!
    } else {
        // Failed
    }
});
ParseObject gameScore = new ParseObject("GameScore");
gameScore.put("score", 1337);
gameScore.put("playerName", "Sean Plott");
gameScore.put("cheatMode", false);
gameScore.saveInBackground(e -> {
    if (e == null) {
        // Success!
    } else {
        // Failed
    }
});
﻿
Um die Daten abzufragen:
Java
ParseQuery<ParseObject> query = ParseQuery.getQuery("GameScore");
query.whereEqualTo("playerName", "Sean Plott");
query.findInBackground((objects, e) -> {
    if (e == null) {
        // objects now contains the results
    } else {
        // something went wrong
    }
});
ParseQuery<ParseObject> query = ParseQuery.getQuery("GameScore");
query.whereEqualTo("playerName", "Sean Plott");
query.findInBackground((objects, e) -> {
    if (e == null) {
        // objects now contains the results
    } else {
        // something went wrong
    }
});
﻿
Alternativ können Sie die REST API Endpunkte von Back4App verwenden:
Curl
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 '{"score": 1337, "playerName": "Sean Plott", "cheatMode": false}' \
  https://parseapi.back4app.com/classes/GameScore
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 '{"score": 1337, "playerName": "Sean Plott", "cheatMode": false}' \
  https://parseapi.back4app.com/classes/GameScore
﻿
Back4App bietet auch eine GraphQL-Schnittstelle:
GraphQL
mutation {
  createGameScore(input: {
    fields: {
      score: 1337
      playerName: "Sean Plott"
      cheatMode: false
    }
  }) {
    gameScore {
      objectId
      score
      playerName
      cheatMode
    }
  }
}
mutation {
  createGameScore(input: {
    fields: {
      score: 1337
      playerName: "Sean Plott"
      cheatMode: false
    }
  }) {
    gameScore {
      objectId
      score
      playerName
      cheatMode
    }
  }
}
﻿
GraphQL
mutation {
  createGameScore(input: {
    fields: {
      score: 1337
      playerName: "Sean Plott"
      cheatMode: false
    }
  }) {
    gameScore {
      objectId
      score
      playerName
      cheatMode
    }
  }
}
mutation {
  createGameScore(input: {
    fields: {
      score: 1337
      playerName: "Sean Plott"
      cheatMode: false
    }
  }) {
    gameScore {
      objectId
      score
      playerName
      cheatMode
    }
  }
}
﻿
Diese vielfältigen Optionen ermöglichen es Ihnen, Datenoperationen auf die Weise zu integrieren, die am besten zu Ihrem Entwicklungsprozess passt – sei es über das Parse Android SDK, REST oder GraphQL.
Schema-Design und Datentypen
Standardmäßig erlaubt Parse Schemaerstellung on-the-fly, aber Sie können auch Ihre Klassen und Datentypen im Back4App-Dashboard definieren, um mehr Kontrolle zu haben:
Navigieren Sie zum Abschnitt “Datenbank” in Ihrem Back4App-Dashboard.
Erstellen Sie eine neue Klasse (z.B. “GameScore”) und fügen Sie relevante Spalten hinzu.
Neue Klasse erstellen
﻿
Back4App unterstützt auch verschiedene Datentypen: String, Number, Boolean, Object, Date, File, Pointer, Array, Relation, GeoPoint, und Polygon. Sie können den geeigneten Typ für jedes Feld auswählen.
Spalte erstellen
﻿
Back4App bietet einen AI-Agenten an, der Ihnen helfen kann, Ihr Datenmodell zu entwerfen:
Öffnen Sie den AI-Agenten von Ihrem App-Dashboard oder im Menü.
Beschreiben Sie Ihr Datenmodell in einfacher Sprache (z.B. “Bitte erstellen Sie eine neue ToDo-App mit einem vollständigen Klassenschema.”).
Lassen Sie den AI-Agenten das Schema für Sie erstellen. 
﻿
Relationale Daten
Wenn Sie relationale Daten haben – sagen wir, ein Kategorie Objekt, das auf mehrere Spielpunktzahlen Objekte verweist – können Sie Zeiger oder Beziehungen in Parse verwenden. Zum Beispiel:
Java
// Linking a GameScore to a Category with a pointer
public void createGameScoreForCategory(String categoryObjectId, int scoreValue) {
    ParseObject gameScore = new ParseObject("GameScore");
    // Construct a pointer to the category
    ParseObject categoryPointer = ParseObject.createWithoutData("Category", categoryObjectId);
    // Set fields
    gameScore.put("score", scoreValue);
    gameScore.put("category", categoryPointer);
    gameScore.saveInBackground(e -> {
        if (e == null) {
            // Success
        } else {
            // Error
        }
    });
}
// Linking a GameScore to a Category with a pointer
public void createGameScoreForCategory(String categoryObjectId, int scoreValue) {
    ParseObject gameScore = new ParseObject("GameScore");
    // Construct a pointer to the category
    ParseObject categoryPointer = ParseObject.createWithoutData("Category", categoryObjectId);
    // Set fields
    gameScore.put("score", scoreValue);
    gameScore.put("category", categoryPointer);
    gameScore.saveInBackground(e -> {
        if (e == null) {
            // Success
        } else {
            // Error
        }
    });
}
﻿
Wenn Sie abfragen, können Sie Zeiger-Daten einbeziehen:
Java
ParseQuery<ParseObject> query = ParseQuery.getQuery("GameScore");
query.include("category");
query.findInBackground((scores, e) -> {
    if (e == null) {
        // scores now has category details
    }
});
ParseQuery<ParseObject> query = ParseQuery.getQuery("GameScore");
query.include("category");
query.findInBackground((scores, e) -> {
    if (e == null) {
        // scores now has category details
    }
});
﻿
Echtzeitabfragen
Für Echtzeit-Updates bietet Back4App Echtzeitabfragen. Sie können Änderungen in einer bestimmten Klasse von Ihrer Android-App abonnieren:
Aktivieren Sie Echtzeitabfragen in Ihrem Back4App-Dashboard unter den Servereinstellungen. 
Initialisieren Sie die Echtzeitabfrage in Ihrem Code.
In Android verlassen Sie sich typischerweise auf die Parse LiveQuery Android-Bibliothek um zu abonnieren. Die Schritte sind ähnlich wie auf anderen Plattformen, aber Sie integrieren einen LiveQueryClient:
Text
dependencies {
    implementation "com.github.parse-community:ParseLiveQuery-Android:latest.version.here"
}
dependencies {
    implementation "com.github.parse-community:ParseLiveQuery-Android:latest.version.here"
}
﻿
Dann:
Java
LiveQueryClient liveQueryClient = new LiveQueryClient.Builder("wss://YOUR_SUBDOMAIN_HERE.b4a.io", 443)
        .build();
ParseQuery<ParseObject> query = ParseQuery.getQuery("GameScore");
SubscriptionHandling<ParseObject> subscriptionHandling = liveQueryClient.subscribe(query);

subscriptionHandling.handleEvents((query1, event, gameScore) -> {
    switch (event) {
        case CREATE:
            // a new GameScore object was created
            break;
        case UPDATE:
            // existing GameScore updated
            break;
        case DELETE:
            // existing GameScore deleted
            break;
        default:
            break;
    }
});
LiveQueryClient liveQueryClient = new LiveQueryClient.Builder("wss://YOUR_SUBDOMAIN_HERE.b4a.io", 443)
        .build();
ParseQuery<ParseObject> query = ParseQuery.getQuery("GameScore");
SubscriptionHandling<ParseObject> subscriptionHandling = liveQueryClient.subscribe(query);

subscriptionHandling.handleEvents((query1, event, gameScore) -> {
    switch (event) {
        case CREATE:
            // a new GameScore object was created
            break;
        case UPDATE:
            // existing GameScore updated
            break;
        case DELETE:
            // existing GameScore deleted
            break;
        default:
            break;
    }
});
﻿
Durch das Abonnieren erhalten Sie Echtzeitbenachrichtigungen, wann immer ein neuer Datensatz erstellt, aktualisiert oder gelöscht wird. Diese Funktion ist besonders wertvoll für kollaborative oder dynamische Apps, in denen mehrere Benutzer die neuesten Daten sehen müssen, ohne die Seite zu aktualisieren.
Schritt 3 – Anwendung von Sicherheit mit ACLs und CLPs
Back4app Sicherheitsmechanismus
Back4App nimmt Sicherheit ernst, indem es Zugriffskontrolllisten (ACLs) und Klassenebene-Berechtigungen (CLPs). Diese Funktionen ermöglichen es Ihnen, einzuschränken, wer Daten auf Objekt- oder Klassenbasis lesen oder schreiben kann, und stellen sicher, dass nur autorisierte Benutzer Ihre Daten ändern können.
﻿
Zugriffskontrolllisten (ACLs)
Eine ACL wird auf einzelne Objekte angewendet, um zu bestimmen, welche Benutzer, Rollen oder die Öffentlichkeit Lese-/Schreiboperationen durchführen können. Zum Beispiel:
Java
public void createPrivateScore(int scoreValue, ParseUser ownerUser) {
    ParseObject gameScore = new ParseObject("GameScore");
    gameScore.put("score", scoreValue);
    ParseACL acl = new ParseACL(ownerUser);
    acl.setPublicReadAccess(false);
    acl.setPublicWriteAccess(false);
    gameScore.setACL(acl);
    gameScore.saveInBackground(e -> {
        if (e == null) {
            // success
        } else {
            // failed
        }
    });
}
public void createPrivateScore(int scoreValue, ParseUser ownerUser) {
    ParseObject gameScore = new ParseObject("GameScore");
    gameScore.put("score", scoreValue);
    ParseACL acl = new ParseACL(ownerUser);
    acl.setPublicReadAccess(false);
    acl.setPublicWriteAccess(false);
    gameScore.setACL(acl);
    gameScore.saveInBackground(e -> {
        if (e == null) {
            // success
        } else {
            // failed
        }
    });
}
﻿
ACL bearbeiten
﻿
Klassenebene Berechtigungen (CLPs)
CLPs regeln die Standardberechtigungen einer gesamten Klasse, wie ob die Klasse öffentlich lesbar oder schreibbar ist oder ob nur bestimmte Rollen darauf zugreifen können.
Gehe zu deinem Back4app Dashboard, wähle deine App aus und öffne den Datenbank Abschnitt.
Wähle eine Klasse aus (z.B. „GameScore“).
Öffne die Klassenebene Berechtigungen Registerkarte.
Konfiguriere deine Standardwerte.
﻿
Diese Berechtigungen setzen die Basis, während ACLs die Berechtigungen für einzelne Objekte verfeinern. Ein robustes Sicherheitsmodell kombiniert typischerweise sowohl CLPs (breite Einschränkungen) als auch ACLs (fein abgestufte Einschränkungen pro Objekt). Für weitere Informationen gehe zu App-Sicherheitsrichtlinien.
Schritt 4 – Schreiben und Bereitstellen von Cloud-Code-Funktionen
Warum Cloud Code
Cloud Code ist eine Funktion der Parse Server-Umgebung, die es Ihnen ermöglicht, benutzerdefinierten JavaScript-Code auf der Serverseite auszuführen – ohne dass Sie Ihre Server oder Infrastruktur verwalten müssen. Durch das Schreiben von Cloud Code können Sie Ihr Back4App-Backend mit zusätzlicher Geschäftslogik, Validierungen, Triggern und Integrationen erweitern, die sicher und effizient auf dem Parse Server ausgeführt werden.
Beispiel-Funktion
Eine einfache Cloud Code-Funktion, die die Länge eines von der Clientseite gesendeten Textstrings berechnet:
main.js
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
﻿
Bereitstellung
Back4App CLI:
Dashboard:
Gehen Sie im Dashboard Ihrer App zu Cloud Code > Funktionen. Kopieren Sie Ihren Code in main.js und klicken Sie auf Bereitstellen.
﻿
Aufrufen Ihrer Funktion
Von Android (Java) unter Verwendung des Parse SDK:
Java
HashMap<String, Object> params = new HashMap<>();
params.put("text", "Hello Back4App");
ParseCloud.callFunctionInBackground("calculateTextLength", params, (result, e) -> {
    if (e == null) {
        // result is a HashMap; get the length
        Map<?, ?> mapResult = (Map<?, ?>) result;
        Object lengthVal = mapResult.get("length");
        // cast to number, etc.
    } else {
        // handle error
    }
});
HashMap<String, Object> params = new HashMap<>();
params.put("text", "Hello Back4App");
ParseCloud.callFunctionInBackground("calculateTextLength", params, (result, e) -> {
    if (e == null) {
        // result is a HashMap; get the length
        Map<?, ?> mapResult = (Map<?, ?>) result;
        Object lengthVal = mapResult.get("length");
        // cast to number, etc.
    } else {
        // handle error
    }
});
﻿
Sie können es auch über REST oder GraphQL. Diese Flexibilität ermöglicht es Ihnen, Ihre benutzerdefinierte Logik in Ihr Android-Frontend oder jeden anderen Client zu integrieren, der REST oder GraphQL unterstützt.
Schritt 5 – Benutzer-Authentifizierung konfigurieren
Benutzer-Authentifizierung in Back4app
Back4App nutzt die Parse User Klasse als Grundlage für die Authentifizierung. Standardmäßig kümmert sich Parse um Passwort-Hashing, Sitzungstoken und sichere Speicherung. Das bedeutet, dass Sie keine komplexen Sicherheitsabläufe manuell einrichten müssen.
Benutzer-Authentifizierung einrichten
In einer Android-Anwendung, die Java verwendet, können Sie einen neuen Benutzer erstellen:
Java
ParseUser user = new ParseUser();
user.setUsername("myUsername");
user.setPassword("myPassword");
user.setEmail("[email protected]");
user.signUpInBackground(e -> {
    if (e == null) {
        // Sign up success
    } else {
        // Sign up failed
    }
});
ParseUser user = new ParseUser();
user.setUsername("myUsername");
user.setPassword("myPassword");
user.setEmail("email@example.com");
user.signUpInBackground(e -> {
    if (e == null) {
        // Sign up success
    } else {
        // Sign up failed
    }
});
﻿
Melden Sie einen bestehenden Benutzer an:
Java
ParseUser.logInInBackground("myUsername", "myPassword", (parseUser, e) -> {
    if (e == null) {
        // Logged in successfully
    } else {
        // Login failed
    }
});
ParseUser.logInInBackground("myUsername", "myPassword", (parseUser, e) -> {
    if (e == null) {
        // Logged in successfully
    } else {
        // Login failed
    }
});
﻿
Über REST könnte eine Anmeldung so aussehen:
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=secret123' \
  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=secret123' \
  https://parseapi.back4app.com/login
﻿
Sitzungsverwaltung
Nach einer erfolgreichen Anmeldung erstellt Parse ein Sitzungstoken das im Benutzerobjekt gespeichert wird. Sie können den aktuell angemeldeten Benutzer überprüfen:
Java
ParseUser currentUser = ParseUser.getCurrentUser();
if (currentUser != null) {
    // user is logged in
} else {
    // no user is logged in
}
ParseUser currentUser = ParseUser.getCurrentUser();
if (currentUser != null) {
    // user is logged in
} else {
    // no user is logged in
}
﻿
Sie können sich abmelden:
Java
ParseUser.logOut();
ParseUser.logOut();
﻿
Integration von sozialem Login
Back4app und Parse können mit beliebten OAuth-Anbietern wie Google oder Facebook. Zum Beispiel können Sie die Facebook-Anmeldung einrichten, indem Sie die Facebook App ID konfigurieren und die speziellen Parse FacebookUtils für Android verwenden. Detaillierte Anweisungen variieren, daher verweisen Sie auf Soziale Anmeldedokumentation.
E-Mail-Verifizierung und Passwortzurücksetzung
Um die E-Mail-Verifizierung und Passwortzurücksetzung zu aktivieren:
Navigieren Sie zu den E-Mail-Einstellungen in Ihrem Back4App-Dashboard.
Aktivieren Sie die E-Mail-Verifizierung.
Konfigurieren Sie die Absenderadresse und die E-Mail-Vorlagen.
Dies hilft sicherzustellen, dass die E-Mail Ihres Benutzers gültig ist und bietet eine sichere Methode zur Wiederherstellung des Passworts.
Schritt 6 – Umgang mit Dateispeicherung
Hochladen und Abrufen von Dateien
Parse enthält die ParseFile-Klasse zum Verarbeiten von Datei-Uploads, die Back4app sicher speichert:
Java
File file = new File("/path/to/image.jpg");
byte[] data = ... // read file as bytes
ParseFile parseFile = new ParseFile("image.jpg", data);
parseFile.saveInBackground(e -> {
    if (e == null) {
        // File saved
    } else {
        // error
    }
});
File file = new File("/path/to/image.jpg");
byte[] data = ... // read file as bytes
ParseFile parseFile = new ParseFile("image.jpg", data);
parseFile.saveInBackground(e -> {
    if (e == null) {
        // File saved
    } else {
        // error
    }
});
﻿
Fügen Sie die Datei einem Objekt hinzu:
Java
ParseObject photo = new ParseObject("Photo");
photo.put("imageFile", parseFile);
photo.saveInBackground();
ParseObject photo = new ParseObject("Photo");
photo.put("imageFile", parseFile);
photo.saveInBackground();
﻿
Rufen Sie die Datei-URL ab:
Java
ParseFile imageFile = photo.getParseFile("imageFile");
String url = imageFile.getUrl();
ParseFile imageFile = photo.getParseFile("imageFile");
String url = imageFile.getUrl();
﻿
Dateisicherheit
Der Parse-Server bietet flexible Konfigurationen zur Verwaltung der Dateiuploadsicherheit, einschließlich der Kontrolle, ob anonyme oder authentifizierte Benutzer Dateien hochladen können. Stellen Sie sicher, dass Sie die Dokumentation für fortgeschrittene Konfigurationen überprüfen.
Schritt 7 – E-Mail-Verifizierung und Passwortzurücksetzung
Übersicht
Die Verifizierung von E-Mails stellt sicher, dass neue Benutzer die E-Mail-Adresse besitzen, die sie zur Anmeldung verwendet haben. Passwortzurücksetzungen ermöglichen es Benutzern, ihre Konten sicher wiederherzustellen.
Back4App-Dashboard-Konfiguration
E-Mail-Verifizierung aktivieren: Gehen Sie im Dashboard Ihrer App zu E-Mail-Einstellungen.
Passwortzurücksetzung aktivieren: Konfigurieren Sie den E-Mail-Fluss zur Passwortzurücksetzung.
Code/Implementierung
Passwortzurücksetzung in Java auslösen:
Java
ParseUser.requestPasswordResetInBackground("[email protected]", e -> {
    if (e == null) {
        // Email sent
    } else {
        // Something went wrong
    }
});
ParseUser.requestPasswordResetInBackground("email@example.com", e -> {
    if (e == null) {
        // Email sent
    } else {
        // Something went wrong
    }
});
﻿
Schritt 8 – Aufgaben mit Cloud-Jobs planen
Cloud-Jobs
Verwenden Sie Cloud-Jobs in Back4App, um wiederkehrende Aufgaben zu planen, wie das Bereinigen alter Daten oder das Versenden täglicher E-Mails. Beispiel:
JS
Parse.Cloud.job('cleanupOldScores', async (request) => {
  const GameScore = Parse.Object.extend('GameScore');
  const query = new Parse.Query(GameScore);
  // e.g., remove scores older than 30 days
  // ...
});
Parse.Cloud.job('cleanupOldScores', async (request) => {
  const GameScore = Parse.Object.extend('GameScore');
  const query = new Parse.Query(GameScore);
  // e.g., remove scores older than 30 days
  // ...
});
﻿
Planen Sie es im Back4App-Dashboard > App-Einstellungen > Servereinstellungen > Hintergrundjobs.
Planung eines Cloud-Jobs
﻿
Schritt 9 – Integration von Webhooks
Webhooks ermöglichen es Ihrer Back4App-App, HTTP-Anfragen an einen externen Dienst zu senden, wenn bestimmte Ereignisse eintreten, z. B. das Senden von Daten an einen Drittanbieterdienst wie Stripe.
Navigieren Sie zu Webhooks in Ihrem Back4App-Dashboard > Mehr > WebHooks.
Webhook hinzufügen mit Ihrem externen Endpunkt.
Trigger konfigurieren für relevante Ereignisse.
Hinzufügen eines Webhooks
﻿
Schritt 10 – Erkundung des Back4App-Admin-Panels
Die Back4app Admin App ist eine webbasierte Verwaltungsoberfläche, die für nicht-technische Benutzer entwickelt wurde. Sie ermöglicht schnelle CRUD-Operationen und routinemäßige Datenverwaltung, ohne dass Code geschrieben werden muss.
Aktivierung der Admin App
Gehen Sie zu App-Dashboard > Mehr > Admin App und klicken Sie auf Admin App aktivieren.
Admin-App aktivieren
﻿
Erstellen Sie einen ersten Admin-Benutzer und eine Subdomain, und Sie haben eine Web-Benutzeroberfläche für die Datenverwaltung.
Fazit
Indem Sie dieses umfassende Tutorial befolgt haben, haben Sie:
Ein sicheres Backend erstellt für eine Android (Java) App auf Back4App.
Eine Datenbank konfiguriert mit Klassenschemas, Datentypen und Beziehungen.
Echtzeitabfragen integriert (Live Queries) für sofortige Datenaktualisierungen.
Sicherheitsmaßnahmen angewendet unter Verwendung von ACLs und CLPs, um den Datenzugriff zu schützen und zu verwalten.
Cloud-Code implementiert Funktionen, um benutzerdefinierte Geschäftslogik auf der Serverseite auszuführen.
Benutzerauthentifizierung eingerichtet mit Unterstützung für E-Mail-Bestätigung und Passwortzurücksetzungen.
Datei-Uploads verwaltet und Abrufe, mit optionalen Datei-Sicherheitskontrollen.
Cloud-Jobs geplant für automatisierte Hintergrundaufgaben.
Webhooks verwendet um mit externen Diensten zu integrieren.
Das Back4App Admin-Panel erkundet für die Datenverwaltung.
Mit einem soliden Android-Frontend (Java) und einem robusten Back4App-Backend sind Sie nun gut gerüstet, um funktionsreiche, skalierbare und sichere Anwendungen zu entwickeln. Erkunden Sie weiterhin fortgeschrittene Funktionen, integrieren Sie Ihre Geschäftslogik und nutzen Sie die Leistungsfähigkeit von Back4App, um Ihnen unzählige Stunden in der Server- und Datenbankadministration zu sparen. Viel Spaß beim Programmieren!
Nächste Schritte
Erstellen Sie eine produktionsbereite Android-App indem Sie dieses Backend erweitern, um komplexere Datenmodelle, Caching-Strategien und Leistungsoptimierungen zu handhaben.
Integrieren Sie fortgeschrittene Funktionen wie spezialisierte Authentifizierungsabläufe, rollenbasierte Zugriffskontrolle oder externe APIs (wie Zahlungs-Gateways).
Sehen Sie sich die offizielle Dokumentation von Back4app an für tiefere Einblicke in fortgeschrittene Sicherheit, Leistungsoptimierung und Protokollanalyse.
Erforschen Sie andere Tutorials zu Echtzeit-Chat-Anwendungen, IoT-Dashboards oder standortbasierten Diensten. Sie können die hier gelernten Techniken mit Drittanbieter-APIs kombinieren, um komplexe, reale Anwendungen zu erstellen.
﻿
Aktualisiert 23 Jan 2025
Hat Ihnen diese Seite geholfen?
Wie man ein Backend für Kotlin aufbaut?
ALS NÄCHSTES
Wie man ein Backend für Remix aufbaut?