Schnellstarter
Wie man ein Backend für Kotlin aufbaut?

38min
Einführung
In diesem Tutorial lernen Sie, wie Sie ein vollständiges Backend für eine Android-Anwendung (geschrieben in Kotlin) mit Back4App erstellen.
Wir werden die Integration wesentlicher Back4App-Funktionen durchgehen – einschließlich 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 Ihrer Android-App 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.
Unterwegs 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/Kotlin-Entwicklungsumgebung
 Stellen Sie sicher, dass Sie Android Studio auf Ihrem Computer installiert haben. Sie können die offiziellen Einrichtungsdokumente von Android Studio befolgen, wenn Sie es noch nicht eingerichtet haben.
Mindestens Android 4.0 oder höher in der Gradle-Konfiguration Ihrer App
Typischerweise setzen Sie dies in Ihrer minSdkVersion in der build.gradle Ihres Moduls.
Vertrautheit mit Kotlin und grundlegenden Android-Konzepten
 Android-Entwicklerdokumente.
Wenn Sie neu in Android oder Kotlin sind, überprüfen 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 einzurichten und Ihre lokale Android-Umgebung vorzubereiten, wird Ihnen helfen, leichter folgen zu können.
Schritt 1 – Einrichten 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-Kotlin-Backend-Tutorial“).
﻿
Sobald das Projekt erstellt ist, sehen Sie es in Ihrem Back4app-Dashboard aufgelistet. Dieses Projekt wird die Grundlage für alle Backend-Konfigurationen sein, die in diesem Tutorial besprochen werden.
Verbinden Sie das Parse SDK
Back4App verlässt sich auf die Parse-Plattform, um Ihre Daten zu verwalten, Echtzeitfunktionen bereitzustellen, die Benutzerauthentifizierung zu handhaben und mehr. Die Integration Ihrer Android-App mit Back4App umfasst das Hinzufügen der Parse Android SDK-Abhängigkeiten zu Ihren Gradle-Dateien und deren Initialisierung mit Anmeldeinformationen von 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. Sie finden auch die Parse-Server-URL (häufig im Format https://parseapi.back4app.com).
﻿
Fügen Sie das Parse SDK zu Ihren build.gradle-Dateien hinzu:
In Ihrer Root- build.gradle (Projekt-Ebene):
Text
allprojects {
    repositories {
        maven { url "https://jitpack.io" }
    }
}
allprojects {
    repositories {
        maven { url "https://jitpack.io" }
    }
}
﻿
In Ihrer Modul-Ebene build.gradle (normalerweise app/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"
}
﻿
Initialisieren Sie Parse in Ihrer Android-Anwendung:
Erstellen Sie eine benutzerdefinierte Application-Klasse (z. B. App.kt), wenn Sie noch keine haben:
Kotlin
package com.example.app

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

class App : Application() {
    override fun onCreate() {
        super.onCreate()

        // Initialize Parse
        Parse.initialize(
            Parse.Configuration.Builder(this)
                .applicationId("YOUR_APP_ID")  // from Back4App Dashboard
                .clientKey("YOUR_CLIENT_KEY")  // from Back4App Dashboard
                .server("https://parseapi.back4app.com/")
                .build()
        )

        // (Optional) Track statistics around app opens
        ParseInstallation.getCurrentInstallation().saveInBackground()
    }
}
package com.example.app

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

class App : Application() {
    override fun onCreate() {
        super.onCreate()

        // Initialize Parse
        Parse.initialize(
            Parse.Configuration.Builder(this)
                .applicationId("YOUR_APP_ID")  // from Back4App Dashboard
                .clientKey("YOUR_CLIENT_KEY")  // from Back4App Dashboard
                .server("https://parseapi.back4app.com/")
                .build()
        )

        // (Optional) Track statistics around app opens
        ParseInstallation.getCurrentInstallation().saveInBackground()
    }
}
﻿
Öffnen Sie als Nächstes Ihre AndroidManifest.xml und registrieren Sie die benutzerdefinierte Application-Klasse:
XML
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.app">

    <application
        android:name=".App"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:usesCleartextTraffic="true"
        ... >
        ...
    </application>

</manifest>
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.app">

    <application
        android:name=".App"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:usesCleartextTraffic="true"
        ... >
        ...
    </application>

</manifest>
﻿
Durch das Abschließen dieses Schrittes haben Sie eine sichere Verbindung zwischen Ihrem Android (Kotlin) 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 nun Daten speichern und abrufen. Im Folgenden finden Sie ein Beispiel, das Kotlin verwendet, um Daten zu erstellen und abzurufen.
Kotlin
import com.parse.ParseObject
import com.parse.ParseQuery
import com.parse.SaveCallback
import com.parse.ParseException

// Example: Create a Todo item
fun createTodoItem(title: String, isCompleted: Boolean) {
    val todo = ParseObject("Todo")
    todo.put("title", title)
    todo.put("isCompleted", isCompleted)

    todo.saveInBackground { e: ParseException? ->
        if (e == null) {
            println("Todo saved successfully")
        } else {
            println("Error saving Todo: ${e.localizedMessage}")
        }
    }
}

// Example: Query all Todo items
fun fetchTodos() {
    val query = ParseQuery<ParseObject>("Todo")
    query.findInBackground { results, e ->
        if (e == null) {
            println("Fetched Todo items: ${results.size}")
        } else {
            println("Error fetching Todos: ${e.localizedMessage}")
        }
    }
}
import com.parse.ParseObject
import com.parse.ParseQuery
import com.parse.SaveCallback
import com.parse.ParseException

// Example: Create a Todo item
fun createTodoItem(title: String, isCompleted: Boolean) {
    val todo = ParseObject("Todo")
    todo.put("title", title)
    todo.put("isCompleted", isCompleted)

    todo.saveInBackground { e: ParseException? ->
        if (e == null) {
            println("Todo saved successfully")
        } else {
            println("Error saving Todo: ${e.localizedMessage}")
        }
    }
}

// Example: Query all Todo items
fun fetchTodos() {
    val query = ParseQuery<ParseObject>("Todo")
    query.findInBackground { results, e ->
        if (e == null) {
            println("Fetched Todo items: ${results.size}")
        } else {
            println("Error fetching Todos: ${e.localizedMessage}")
        }
    }
}
﻿
Alternativ können Sie die REST-API-Endpunkte von Back4App verwenden:
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
﻿
Back4app bietet auch eine GraphQL-Schnittstelle:
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
    }
  }
}
﻿
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 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. “Todo”) und fügen Sie relevante Spalten hinzu, wie Titel (String) und isCompleted (Boolean).
Neue Klasse erstellen
﻿
Back4app bietet einen KI-Agenten, der Ihnen helfen kann, Ihr Datenmodell zu entwerfen:
Öffnen Sie den KI-Agenten von Ihrem App-Dashboard oder im Menü.
Beschreiben Sie Ihr Datenmodell in einfacher Sprache (z. B. “Bitte erstellen Sie eine neue ToDo-App bei Back4app mit einem vollständigen Klassenschema.”).
Lassen Sie den KI-Agenten das Schema für Sie erstellen. 
﻿
Die Verwendung des KI-Agenten kann Ihnen Zeit bei der Einrichtung Ihrer Datenarchitektur sparen und Konsistenz in Ihrer Anwendung gewährleisten.
Relationale Daten
Wenn Sie relationale Daten haben—sagen wir, ein Category Objekt, das auf mehrere Todo Elemente verweist—können Sie Pointers oder Relations in Parse verwenden. Zum Beispiel, um einen Zeiger auf eine Category:
Kotlin
// Linking a Todo to a Category with a pointer
fun createTaskForCategory(categoryObjectId: String, title: String) {
    val todo = ParseObject("Todo")
    val categoryPointer = ParseObject("Category")
    categoryPointer.objectId = categoryObjectId

    todo.put("title", title)
    todo.put("category", categoryPointer)

    todo.saveInBackground { e ->
        if (e == null) {
            println("Created Task with category relationship")
        } else {
            println("Error creating Task: ${e.localizedMessage}")
        }
    }
}
// Linking a Todo to a Category with a pointer
fun createTaskForCategory(categoryObjectId: String, title: String) {
    val todo = ParseObject("Todo")
    val categoryPointer = ParseObject("Category")
    categoryPointer.objectId = categoryObjectId

    todo.put("title", title)
    todo.put("category", categoryPointer)

    todo.saveInBackground { e ->
        if (e == null) {
            println("Created Task with category relationship")
        } else {
            println("Error creating Task: ${e.localizedMessage}")
        }
    }
}
﻿
Wenn Sie abfragen, können Sie auch Zeiger-Daten einbeziehen:
Kotlin
val query = ParseQuery.getQuery<ParseObject>("Todo")
query.include("category")
query.findInBackground { todos, e ->
    if (e == null) {
        println("Fetched ${todos.size} todos with category data")
    }
}
val query = ParseQuery.getQuery<ParseObject>("Todo")
query.include("category")
query.findInBackground { todos, e ->
    if (e == null) {
        println("Fetched ${todos.size} todos with category data")
    }
}
﻿
Dieser include("category") Aufruf ruft die Kategoriedetails zusammen mit jedem Todo ab, wodurch Ihre relationalen Daten nahtlos zugänglich werden.
Echtzeitabfragen
Für Echtzeit-Updates bietet Back4app Live Queries. Sie können Änderungen in einer bestimmten Klasse von Ihrer Android-App abonnieren:
Aktivieren Sie Live Queries in Ihrem Back4App-Dashboard unter den Servereinstellungen.
Initialisieren Sie ein Live Query-Abonnement in Ihrem Code:
Kotlin
import com.parse.ParseLiveQueryClient
import com.parse.ParseQuery
import com.parse.SubscriptionHandling
...

val parseLiveQueryClient = ParseLiveQueryClient.Factory.getClient()
val parseQuery = ParseQuery<ParseObject>("Todo")

val subscriptionHandling: SubscriptionHandling<ParseObject> =
    parseLiveQueryClient.subscribe(parseQuery)

subscriptionHandling.handleEvent(SubscriptionHandling.Event.CREATE) { queryTodo, todo ->
    println("New Todo created: ${todo.getString("title")}")
}
subscriptionHandling.handleEvent(SubscriptionHandling.Event.UPDATE) { queryTodo, todo ->
    println("Todo updated: ${todo.getString("title")}")
}
subscriptionHandling.handleEvent(SubscriptionHandling.Event.DELETE) { queryTodo, todo ->
    println("Todo deleted: ${todo.getString("title")}")
}
import com.parse.ParseLiveQueryClient
import com.parse.ParseQuery
import com.parse.SubscriptionHandling
...

val parseLiveQueryClient = ParseLiveQueryClient.Factory.getClient()
val parseQuery = ParseQuery<ParseObject>("Todo")

val subscriptionHandling: SubscriptionHandling<ParseObject> =
    parseLiveQueryClient.subscribe(parseQuery)

subscriptionHandling.handleEvent(SubscriptionHandling.Event.CREATE) { queryTodo, todo ->
    println("New Todo created: ${todo.getString("title")}")
}
subscriptionHandling.handleEvent(SubscriptionHandling.Event.UPDATE) { queryTodo, todo ->
    println("Todo updated: ${todo.getString("title")}")
}
subscriptionHandling.handleEvent(SubscriptionHandling.Event.DELETE) { queryTodo, todo ->
    println("Todo deleted: ${todo.getString("title")}")
}
﻿
Immer wenn ein neues Todo erstellt, aktualisiert oder gelöscht wird, erhält der Client in Echtzeit einen Callback – perfekt für kollaborative oder dynamische Apps.
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:
Kotlin
fun createPrivateTodo(title: String, ownerUser: ParseObject) {
    val todo = ParseObject("Todo")
    todo.put("title", title)

    // Create an ACL granting read/write access only to the owner
    val acl = com.parse.ParseACL(ownerUser)
    acl.publicReadAccess = false
    acl.publicWriteAccess = false

    todo.acl = acl

    todo.saveInBackground { e ->
        if (e == null) {
            println("Saved private todo")
        } else {
            println("Error: ${e.localizedMessage}")
        }
    }
}
fun createPrivateTodo(title: String, ownerUser: ParseObject) {
    val todo = ParseObject("Todo")
    todo.put("title", title)

    // Create an ACL granting read/write access only to the owner
    val acl = com.parse.ParseACL(ownerUser)
    acl.publicReadAccess = false
    acl.publicWriteAccess = false

    todo.acl = acl

    todo.saveInBackground { e ->
        if (e == null) {
            println("Saved private todo")
        } else {
            println("Error: ${e.localizedMessage}")
        }
    }
}
﻿
Klassenebene Berechtigungen (CLPs)
CLPs regeln die Standardberechtigungen einer gesamten Klasse, wie z.B. ob die Klasse öffentlich lesbar oder schreibbar ist.
Gehen Sie zu Ihrem Back4app Dashboard, wählen Sie Ihre App aus und öffnen Sie den Datenbank-Bereich.
Wählen Sie eine Klasse aus (z.B. „Todo“).
Öffnen Sie die Klassenebene Berechtigungen-Registerkarte.
Konfigurieren Sie Ihre Standardwerte, wie „Benötigt Authentifizierung“ für Lesen oder Schreiben oder „Kein Zugriff“ für die Öffentlichkeit.
﻿
Schritt 4 – Schreiben von Cloud-Code-Funktionen
Cloud Code ermöglicht es Ihnen, benutzerdefinierten Kotlin-ähnlichen JavaScript-Code auf dem Parse Server auszuführen (hochgeladen als .js-Dateien), ohne die Serverinfrastruktur verwalten zu müssen. Dies ist ideal für Geschäftslogik, Validierungen, Trigger und externe API-Aufrufe.
Wie es funktioniert
Sie platzieren typischerweise JavaScript-Funktionen, Trigger und alle erforderlichen npm-Module in einer main.js-Datei. Diese Datei wird in Ihrem Back4App-Projekt bereitgestellt und läuft in der Parse-Server-Umgebung.
Typische Anwendungsfälle
Geschäftslogik
Datenvalidierungen
Trigger (wie beforeSave, afterSave)
Sicherheitsdurchsetzung
Integrationen mit Drittanbieter-APIs
Ihre Funktion bereitstellen
Unten finden Sie eine einfache Cloud-Code-Funktion:
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 über die Back4App CLI:
Bash
# For Linux/Mac
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash

# For Windows, download the .exe from the releases page
# For Linux/Mac
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash

# For Windows, download the .exe from the releases page
﻿
Konfigurieren und bereitstellen:
Bash
b4a configure accountkey
b4a deploy
b4a configure accountkey
b4a deploy
﻿
Rufen Sie Ihre Funktion auf
Von Ihrem Android (Kotlin) Code über das Parse SDK:
Kotlin
import com.parse.ParseCloud
import com.parse.FunctionCallback
import com.parse.ParseException

fun callTextLengthFunction(someText: String) {
    val params = hashMapOf("text" to someText)
    ParseCloud.callFunctionInBackground<Map<String, Any>>("calculateTextLength", params) { result, e ->
        if (e == null) {
            val length = result["length"] as Int
            println("Text length: $length")
        } else {
            println("Error calling Cloud Code: ${e.localizedMessage}")
        }
    }
}
import com.parse.ParseCloud
import com.parse.FunctionCallback
import com.parse.ParseException

fun callTextLengthFunction(someText: String) {
    val params = hashMapOf("text" to someText)
    ParseCloud.callFunctionInBackground<Map<String, Any>>("calculateTextLength", params) { result, e ->
        if (e == null) {
            val length = result["length"] as Int
            println("Text length: $length")
        } else {
            println("Error calling Cloud Code: ${e.localizedMessage}")
        }
    }
}
﻿
Sie können es auch über REST oder GraphQL auf ähnliche Weise aufrufen.
Schritt 5 – Authentifizierung konfigurieren
Benutzerauthentifizierung in Back4App
Back4App nutzt die Parse User Klasse zur Authentifizierung. Parse kümmert sich um sichere Passwort-Hashing, Sitzungstoken und mehr von Haus aus.
Einrichten der Benutzerauthentifizierung
In Kotlin können Sie einen neuen Benutzer erstellen:
Kotlin
import com.parse.ParseUser
...
fun signUpUser(username: String, password: String, email: String) {
    val user = ParseUser()
    user.username = username
    user.setPassword(password)
    user.email = email

    user.signUpInBackground { e ->
        if (e == null) {
            println("User signed up successfully!")
        } else {
            println("Error signing up user: ${e.localizedMessage}")
        }
    }
}
import com.parse.ParseUser
...
fun signUpUser(username: String, password: String, email: String) {
    val user = ParseUser()
    user.username = username
    user.setPassword(password)
    user.email = email

    user.signUpInBackground { e ->
        if (e == null) {
            println("User signed up successfully!")
        } else {
            println("Error signing up user: ${e.localizedMessage}")
        }
    }
}
﻿
Melden Sie einen bestehenden Benutzer an:
Kotlin
fun logInUser(username: String, password: String) {
    ParseUser.logInInBackground(username, password) { user, e ->
        if (user != null && e == null) {
            println("User logged in: ${user.username}")
        } else {
            println("Error logging in: ${e?.localizedMessage}")
        }
    }
}
fun logInUser(username: String, password: String) {
    ParseUser.logInInBackground(username, password) { user, e ->
        if (user != null && e == null) {
            println("User logged in: ${user.username}")
        } else {
            println("Error logging in: ${e?.localizedMessage}")
        }
    }
}
﻿
Soziale Logins wie Google, Facebook und Apple können ebenfalls integriert werden. Überprüfen Sie die Dokumentation zu sozialen Logins für Details.
Sitzungsverwaltung
Parse verwaltet automatisch Sitzungstoken. Sie können auf den aktuellen Benutzer zugreifen:
Kotlin
val currentUser = ParseUser.getCurrentUser()
if (currentUser != null) {
    println("Currently logged-in user: ${currentUser.username}")
} else {
    println("No user is logged in")
}
val currentUser = ParseUser.getCurrentUser()
if (currentUser != null) {
    println("Currently logged-in user: ${currentUser.username}")
} else {
    println("No user is logged in")
}
﻿
Und abmelden:
Kotlin
ParseUser.logOut()
ParseUser.logOut()
﻿
Schritt 6 – Umgang mit Dateispeicher
Hochladen und Abrufen von Dateien
Parse enthält die ParseFile Klasse zum Verarbeiten von Datei-Uploads:
Kotlin
import com.parse.ParseFile
import com.parse.ParseException

fun uploadImage(file: java.io.File) {
    val bytes = file.readBytes()
    val parseFile = ParseFile(file.name, bytes)

    parseFile.saveInBackground { e: ParseException? ->
        if (e == null) {
            println("File saved: ${parseFile.url}")
        } else {
            println("Error uploading file: ${e.localizedMessage}")
        }
    }
}
import com.parse.ParseFile
import com.parse.ParseException

fun uploadImage(file: java.io.File) {
    val bytes = file.readBytes()
    val parseFile = ParseFile(file.name, bytes)

    parseFile.saveInBackground { e: ParseException? ->
        if (e == null) {
            println("File saved: ${parseFile.url}")
        } else {
            println("Error uploading file: ${e.localizedMessage}")
        }
    }
}
﻿
Parse enthält die ParseFile Klasse zum Verarbeiten von Datei-Uploads:
Dateisicherheit
Sie können steuern, wer Dateien hochladen oder herunterladen kann, indem Sie ACLs und CLPs anpassen oder dateispezifische Einstellungen in der Parse-Server-Konfiguration verwenden.
Schritt 7 – E-Mail-Verifizierung und Passwortzurücksetzung
Aktivieren Sie die E-Mail-Verifizierung in Ihren Back4App-Dashboard-Einstellungen.
Konfigurieren Sie Ihre Absenderadresse, E-Mail-Vorlagen oder benutzerdefinierte Domain, falls gewünscht.
Verwenden Sie ParseUser.requestPasswordResetInBackground(email, callback) um einen Passwortzurücksetzungsprozess in Ihrer App auszulösen.
Schritt 8 – Aufgaben mit Cloud-Jobs planen
Cloud-Jobs ermöglichen es Ihnen, Routineaufgaben wie das Bereinigen von Daten oder das Senden von regelmäßigen Benachrichtigungen zu automatisieren.
JS
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo')
  const query = new Parse.Query(Todo)
  // e.g., remove todos older than 30 days
  const cutoff = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000)
  query.lessThan('createdAt', cutoff)

  const oldTodos = await query.find({ useMasterKey: true })
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true })
  return `Deleted ${oldTodos.length} old Todos.`
})
Parse.Cloud.job('cleanupOldTodos', async (request) => {
  const Todo = Parse.Object.extend('Todo')
  const query = new Parse.Query(Todo)
  // e.g., remove todos older than 30 days
  const cutoff = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000)
  query.lessThan('createdAt', cutoff)

  const oldTodos = await query.find({ useMasterKey: true })
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true })
  return `Deleted ${oldTodos.length} old Todos.`
})
﻿
Planen Sie den Job in Ihrem Back4App-Dashboard unter Servereinstellungen > Hintergrundjobs.
Schritt 9 – Integration von Webhooks
Webhooks ermöglichen es Ihrer Back4App-App, HTTP-Anfragen an einen externen Dienst zu senden, wann immer bestimmte Ereignisse auftreten.
Fügen Sie einen Webhook hinzu in Ihrem Back4App-Dashboard unter Mehr > Webhooks.
Trigger konfigurieren (z. B. nach dem Speichern eines neuen Objekts).
Fügen Sie einen URL-Endpunkt hinzu (wie einen Slack- oder Stripe-Webhook).
Hinzufügen eines Webhooks
﻿
Schritt 10 – Erkundung des Back4App-Admin-Panels
Die Back4App Admin App ist eine benutzerfreundliche webbasierte Schnittstelle für nicht-technische Benutzer zur Verwaltung von Daten.
Aktivieren Sie es unter App-Dashboard > Mehr > Admin-App.
Erstellen Sie Ihren ersten Admin-Benutzer.
Wählen Sie eine Subdomain aus, um auf das Admin-Panel zuzugreifen.
Anmelden um Datensätze in Ihrer Datenbank einfach anzuzeigen, zu bearbeiten oder zu entfernen.
Admin-App aktivieren
﻿
Fazit
Durch das Befolgen dieses umfassenden Tutorials haben Sie:
Ein sicheres Backend für eine Android-App auf Back4App erstellt.
Eine Datenbank mit Klassenschemas, Datentypen und Beziehungen konfiguriert.
Echtzeitabfragen (Live Queries) für sofortige Datenaktualisierungen integriert.
Sicherheitsmaßnahmen mit ACLs und CLPs angewendet, um den Datenzugriff zu schützen und zu verwalten.
Cloud-Code Funktionen implementiert, um benutzerdefinierte Geschäftslogik auf der Serverseite auszuführen.
Benutzerauthentifizierung mit Unterstützung für E-Mail-Verifizierung und Passwortzurücksetzungen eingerichtet.
Datei-Uploads und -abrufe verwaltet, mit optionalen Datei-Sicherheitskontrollen.
Cloud-Jobs für automatisierte Hintergrundaufgaben geplant.
Webhooks verwendet, um sich mit externen Diensten zu integrieren.
Das Back4App Admin-Panel für die Datenverwaltung erkundet.
Mit einem soliden Android (Kotlin) Frontend und einem robusten Back4App Backend sind Sie nun gut gerüstet, um funktionsreiche, skalierbare und sichere Anwendungen zu entwickeln. Setzen Sie Ihre Erkundung fort, integrieren Sie Ihre Geschäftslogik und nutzen Sie die Möglichkeiten von Back4App, um Ihnen unzählige Stunden in der Server- und Datenbankverwaltung zu sparen. Viel Spaß beim Programmieren!
Nächste Schritte
Erstellen Sie eine produktionsbereite Android-App durch die Erweiterung dieses Backends, um komplexere Datenmodelle, Caching-Strategien und Leistungsoptimierungen zu handhaben.
Integrieren Sie erweiterte 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 erweiterte Sicherheit, Leistungsoptimierung und Protokollanalyse.
Erforschen Sie andere Tutorials zu Echtzeit-Chat-Anwendungen, IoT-Dashboards oder standortbasierten Diensten. Sie können die hier erlernten 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 Swift erstellt?
ALS NÄCHSTES
Wie man ein Backend für Android erstellt?