Schnellstarter
Wie man ein Backend für Flutter erstellt?

40min
Einführung
In diesem Tutorial lernen Sie wie man ein Backend für Flutter mit Back4app, einem Open-Source und zuverlässigen Backend-as-a-Service (BaaS), erstellt. 
Wir werden die Integration wesentlicher Back4app-Funktionen – wie Datenbankverwaltung, Cloud-Funktionen, RESTful APIs, GraphQL APIs und Benutzerauthentifizierung – in Ihr Flutter-Projekt durchgehen. 
Sie werden auch entdecken, wie man Echtzeit-Updates mit Live Queries verarbeitet. Durch die Nutzung der leistungsstarken Backend-Server von Back4app können Sie viel von der manuellen Konfiguration überspringen und sich auf die Erstellung einer dynamischen Flutter-App konzentrieren.
Dieser Leitfaden zeigt Flutter-Entwicklern, wie sie eine sichere, skalierbare und robuste Backend-Struktur einrichten, die mühelos mit Ihrer Client-Seite kommuniziert. 
Wir werden auch die Vorteile hervorheben, die Back4app beim Handling von schweren Aufgaben – wie Hosting, Benutzerauthentifizierung und Serverlogik – bietet, damit Sie von Funktionen wie automatischer Skalierung, erweiterter Sicherheit und vereinfachter Wartung profitieren können. 
Wenn Sie ein Flutter-Projekt haben und unzählige Stunden bei der Backend-Einrichtung sparen möchten, sind Sie hier genau richtig.
Am Ende dieses Tutorials werden Sie verstehen, welche Art von Backend Sie mit Back4app erstellen können, und bereit sein, Ihre Backend-Dienste für eine produktionsbereite Anwendung zu erweitern oder komplexere Funktionen wie externe APIs und erweiterte Benutzerauthentifizierung zu integrieren. 
Lass uns anfangen!
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 Flutter-Entwicklungsumgebung
 Stellen Sie sicher, dass Sie das Flutter SDK installiert und eingerichtet haben. Bestätigen Sie auch, dass Sie eine IDE (wie Android Studio oder VS Code) für Flutter konfiguriert haben.
Dart (Programmiersprache) Umgebung
Normalerweise wird dies zusammen mit Flutter installiert. Stellen Sie sicher, dass Sie Dart-Pakete ohne Fehler importieren können.
Vertrautheit mit den Grundlagen von Flutter
 Offizielle Flutter-Dokumentation.
Wenn Sie neu bei Flutter sind, lesen Sie die offiziellen Dokumente oder ein Tutorial für Anfänger, bevor Sie beginnen.
Stellen Sie sicher, dass Sie alle diese Voraussetzungen erfüllt haben. Ihr Back4app-Projekt eingerichtet und Ihre lokale Flutter-Umgebung konfiguriert zu haben, wird Ihnen helfen, leichter folgen zu können.
Schritt 1 – Erstellen eines neuen Projekts auf Back4App und Verbindung herstellen
Neues Projekt erstellen
Der erste Schritt beim Erstellen Ihres Flutter-Backends auf Back4app besteht darin, ein neues Projekt zu erstellen. Wenn Sie noch keines erstellt haben, 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. „Flutter-Backend-Tutorial“).
﻿
Sobald das Projekt erstellt ist, sehen Sie es in Ihrem Back4app-Dashboard aufgeführt. Dieses Projekt wird die Grundlage für alle Backend-Konfigurationen sein, die wir besprechen werden.
Installieren und Initialisieren des Parse SDK in Ihrer Flutter-App
Back4app basiert auf der Parse-Plattform, um Ihre Daten, Echtzeit-Updates, Benutzerauthentifizierung und mehr zu verwalten. Um Ihr Flutter-Projekt mit Back4app zu verbinden, befolgen Sie diese Schritte:
Fügen Sie das Parse Flutter SDK zu Ihrer App hinzu:
YAML
dependencies:
  parse_server_sdk_flutter: ^4.0.0
dependencies:
  parse_server_sdk_flutter: ^4.0.0
﻿
Importieren Sie das Parse-Paket in Ihre main.dart (oder wo auch immer Sie Ihre App initialisieren):
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:flutter/material.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  const keyApplicationId = 'YOUR_APPLICATION_ID';
  const keyParseServerUrl = 'https://parseapi.back4app.com';
  const keyClientKey = 'YOUR_CLIENT_KEY';

  // Initialize Parse with debug set to true
  await Parse().initialize(
    keyApplicationId,
    keyParseServerUrl,
    clientKey: keyClientKey,
    autoSendSessionId: true,
    debug: true, 
  );

  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter + Back4App Example',
      theme: ThemeData(primarySwatch: Colors.blue),
      home: const Scaffold(
        body: Center(
          child: Text('Hello from Flutter + Back4App!'),
        ),
      ),
    );
  }
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:flutter/material.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  const keyApplicationId = 'YOUR_APPLICATION_ID';
  const keyParseServerUrl = 'https://parseapi.back4app.com';
  const keyClientKey = 'YOUR_CLIENT_KEY';

  // Initialize Parse with debug set to true
  await Parse().initialize(
    keyApplicationId,
    keyParseServerUrl,
    clientKey: keyClientKey,
    autoSendSessionId: true,
    debug: true, 
  );

  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter + Back4App Example',
      theme: ThemeData(primarySwatch: Colors.blue),
      home: const Scaffold(
        body: Center(
          child: Text('Hello from Flutter + Back4App!'),
        ),
      ),
    );
  }
}
﻿
Gehen Sie in Ihrem Back4app-Dashboard zum Sicherheits- und Schlüssel-Bereich, um Ihre Anwendungs-ID, Client-Schlüssel, und Parse-Server-URL. Ersetzen Sie die Platzhalter oben durch Ihre eigenen Anmeldeinformationen. Mit dieser Initialisierung wird jede Anfrage von Ihrer Flutter-App sicher an Ihre Back4app-Instanz weitergeleitet.
Denken Sie daran, dass der Master-Schlüssel niemals auf der Client-Seite Ihrer Flutter-App verwendet werden sollte. Wenn Sie den Master-Schlüssel benötigen, bewahren Sie ihn auf dem Server oder in einer sicheren Umgebung auf.
Schritt 2 – Datenbank einrichten
Erstellen eines Datenmodells
Sobald Ihre Flutter-App mit Back4app verbunden ist, können Sie mit dem Entwerfen Ihres Datenbankschemas beginnen. Sie können dies manuell über das Back4app-Dashboard tun:
Navigieren Sie zum Abschnitt “Datenbank” in Ihrem Dashboard.
Erstellen Sie eine neue Klasse (z. B. “Todo”) und fügen Sie relevante Spalten hinzu (z. B. Titel, istAbgeschlossen).
Neue Klasse erstellen
﻿
Back4app bietet auch einen KI-Agenten an, um bei der automatischen Schemaerstellung zu helfen:
Öffnen Sie den KI-Agenten über Ihr App-Dashboard oder das Menü.
Beschreiben Sie Ihr Datenmodell in einfacher Sprache (z.B. „Erstellen Sie eine neue ToDo-App mit einem vollständigen Klassenschema.“).
Lassen Sie den KI-Agenten das Schema für Sie erstellen.
﻿
Dies vereinfacht die Einrichtung der Datenarchitektur. Wenn Sie möchten, dass Felder automatisch erstellt werden, können Sie einfach beginnen, Objekte aus Ihrer App zu speichern – Parse unterstützt die Erstellung von Schemata in Echtzeit.
Erstellen eines Datenmodells mit dem KI-Agenten
Wenn Sie sich entscheiden, den Back4app KI-Agenten zu verwenden, geben Sie einfach eine kurze Beschreibung an, und er wird ein Schema für Sie erstellen oder vorschlagen. Dies ist eine hervorragende Möglichkeit, die anfängliche Phase der Datenmodellierung Ihres Flutter-Projekts zu beschleunigen.
Daten lesen und schreiben mit dem Flutter Parse SDK
Im Folgenden finden Sie ein einfaches Beispiel, das zeigt, wie Sie Objekte mit dem Parse Flutter SDK erstellen und abrufen können.
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> createTodoItem(String title, bool isCompleted) async {
  final todo = ParseObject('Todo')
    ..set('title', title)
    ..set('isCompleted', isCompleted);

  final response = await todo.save();
  if (response.success && response.result != null) {
    print('Todo saved successfully: ${response.result}');
  } else {
    print('Error saving Todo: ${response.error?.message}');
  }
}

Future<List<ParseObject>?> fetchTodos() async {
  final QueryBuilder<ParseObject> queryTodo =
      QueryBuilder<ParseObject>(ParseObject('Todo'));

  final response = await queryTodo.query();
  if (response.success && response.results != null) {
    print('Fetched Todo items: ${response.results}');
    return response.results as List<ParseObject>;
  } else {
    print('Error fetching Todos: ${response.error?.message}');
    return null;
  }
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> createTodoItem(String title, bool isCompleted) async {
  final todo = ParseObject('Todo')
    ..set('title', title)
    ..set('isCompleted', isCompleted);

  final response = await todo.save();
  if (response.success && response.result != null) {
    print('Todo saved successfully: ${response.result}');
  } else {
    print('Error saving Todo: ${response.error?.message}');
  }
}

Future<List<ParseObject>?> fetchTodos() async {
  final QueryBuilder<ParseObject> queryTodo =
      QueryBuilder<ParseObject>(ParseObject('Todo'));

  final response = await queryTodo.query();
  if (response.success && response.results != null) {
    print('Fetched Todo items: ${response.results}');
    return response.results as List<ParseObject>;
  } else {
    print('Error fetching Todos: ${response.error?.message}');
    return null;
  }
}
﻿
Damit können Sie direkt mit Ihrer Back4app-Datenbank von Ihrer Flutter-App aus interagieren. Rufen Sie einfach createTodoItem('Füttere die Katze', false) oder fetchTodos() auf, um Daten zu schreiben und zu lesen.
Daten lesen und schreiben mit der REST-API
Wenn Sie mit anderen Diensten integrieren müssen oder einen traditionelleren Ansatz bevorzugen, können Sie weiterhin die Back4app REST-API 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
﻿
Daten lesen und schreiben mit der GraphQL-API
Back4app bietet auch einen GraphQL-Endpunkt an:
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
    }
  }
}
﻿
Dies gibt Ihnen die Flexibilität, den besten Ansatz für Ihre Flutter-App zu entwickeln.
Arbeiten mit Live-Abfragen
Back4app bietet Live-Abfragen an, damit Sie Echtzeit-Updates Ihrer Daten erhalten können. Aktivieren Sie Live-Abfragen im Back4app-Dashboard (Servereinstellungen) und verwenden Sie dann den Parse LiveQuery Flutter-Client.
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:parse_server_sdk_flutter/live_query.dart';

Future<void> subscribeToTodos() async {
  final liveQuery = LiveQuery();
  final query = QueryBuilder<ParseObject>(ParseObject('Todo'));

  Subscription subscription = await liveQuery.client.subscribe(query);

  subscription.on(LiveQueryEvent.create, (value) {
    print('New Todo created: $value');
  });

  subscription.on(LiveQueryEvent.update, (value) {
    print('Todo updated: $value');
  });

  subscription.on(LiveQueryEvent.delete, (value) {
    print('Todo deleted: $value');
  });
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:parse_server_sdk_flutter/live_query.dart';

Future<void> subscribeToTodos() async {
  final liveQuery = LiveQuery();
  final query = QueryBuilder<ParseObject>(ParseObject('Todo'));

  Subscription subscription = await liveQuery.client.subscribe(query);

  subscription.on(LiveQueryEvent.create, (value) {
    print('New Todo created: $value');
  });

  subscription.on(LiveQueryEvent.update, (value) {
    print('Todo updated: $value');
  });

  subscription.on(LiveQueryEvent.delete, (value) {
    print('Todo deleted: $value');
  });
}
﻿
Mit diesem Abonnement können Sie Datenänderungen in Echtzeit verfolgen. Dies ist fantastisch für den Aufbau von kollaborativen Apps, bei denen mehrere Benutzer Live-Datenaktualisierungen sehen. Sobald das Hot Reload ausgelöst wird, bleibt Ihr Abonnement bestehen, es sei denn, die App wird neu gestartet.
Schritt 3 – Anwendung von Sicherheit mit ACLs und CLPs
Was sind ACLs und CLPs?
Back4app verwendet ACLs (Zugriffskontrolllisten) und CLPs (Klassenebene-Berechtigungen) um einzuschränken, wer Daten auf Objekt- und Klassenebene lesen oder schreiben kann. Diese Schicht stellt sicher, dass Ihre Daten vor unbefugtem Zugriff geschützt sind.
Einrichten von Klassenebene-Berechtigungen
Gehe in deinem Back4app-Dashboard zu Datenbank und wähle eine Klasse (z.B. „Todo“).
Navigiere zu Klassenebene Berechtigungen.
Setze Standardwerte (z.B. nur authentifizierte Benutzer können neue Objekte erstellen).
﻿
Konfigurieren von ACLs im Code
Du kannst auch ACLs auf Objektebene aus dem Flutter-Code anwenden:
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> createPrivateTodo(ParseUser ownerUser, String title) async {
  final todo = ParseObject('Todo')..set('title', title);

  final acl = ParseACL(owner: ownerUser);
  acl.setPublicReadAccess(allowed: false);
  acl.setPublicWriteAccess(allowed: false);

  todo.setACL(acl);

  final response = await todo.save();
  if (response.success) {
    print('Private Todo saved.');
  } else {
    print('Error: ${response.error?.message}');
  }
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> createPrivateTodo(ParseUser ownerUser, String title) async {
  final todo = ParseObject('Todo')..set('title', title);

  final acl = ParseACL(owner: ownerUser);
  acl.setPublicReadAccess(allowed: false);
  acl.setPublicWriteAccess(allowed: false);

  todo.setACL(acl);

  final response = await todo.save();
  if (response.success) {
    print('Private Todo saved.');
  } else {
    print('Error: ${response.error?.message}');
  }
}
﻿
Durch die Kombination von CLPs und ACLs kannst du sicherstellen, dass nur die richtigen Personen oder Rollen auf bestimmte Daten zugreifen oder diese ändern können.
Schritt 4 – Schreiben von Cloud-Code-Funktionen
Warum Cloud-Code?
Cloud Code ermöglicht es Ihnen, serverseitige Logik auszuführen, ohne manuell Backend-Server einzurichten. Dies ist perfekt, um Daten zu validieren, mit externen Diensten zu integrieren oder bestimmte Regeln in Ihrem Backend als Service (BaaS) durchzusetzen.
Beispiel-Funktion
Hier ist ein Beispiel für eine Cloud-Funktion, die die Länge eines Textes berechnet:
JS
// main.js in your Cloud Code
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
// main.js in your Cloud Code
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
﻿
Sie können diesen Code über die Back4app CLI oder im Dashboard Ihrer App unter Cloud Code.
Bereitstellung
Verwendung der Back4app CLI:
Bash
b4a configure accountkey
b4a deploy
b4a configure accountkey
b4a deploy
﻿
Verwendung des Dashboards:
Gehen Sie im Dashboard Ihrer App zu Cloud Code > Funktionen.
Fügen Sie den JavaScript-Code ein.
Klicken Sie auf Bereitstellen.
﻿
Cloud Code von Flutter aufrufen
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> getTextLength(String text) async {
  final function = ParseCloudFunction('calculateTextLength');
  final params = <String, dynamic>{'text': text};

  final ParseResponse result = await function.execute(parameters: params);
  if (result.success && result.result != null) {
    print('Text length: ${result.result['length']}');
  } else {
    print('Error calling Cloud Code: ${result.error?.message}');
  }
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> getTextLength(String text) async {
  final function = ParseCloudFunction('calculateTextLength');
  final params = <String, dynamic>{'text': text};

  final ParseResponse result = await function.execute(parameters: params);
  if (result.success && result.result != null) {
    print('Text length: ${result.result['length']}');
  } else {
    print('Error calling Cloud Code: ${result.error?.message}');
  }
}
﻿
Dieser sichere Ansatz stellt sicher, dass sensible Logik auf dem Server bleibt, während Ihre Flutter-App einfach Anfragen stellt.
Schritt 5 – Authentifizierung konfigurieren
Benutzerauthentifizierung aktivieren
Back4app verwendet die Parse.User Klasse, um die Benutzerregistrierung und -anmeldung zu verwalten. Standardmäßig kümmert sich Parse um die Passwort-Hashing, Sitzungstoken und sichere Speicherung.
Dart
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> signUpUser(String username, String password, String email) async {
  final user = ParseUser(username, password, email);
  final response = await user.signUp();
  if (response.success) {
    print('User signed up successfully!');
  } else {
    print('Sign up error: ${response.error?.message}');
  }
}

Future<void> logInUser(String username, String password) async {
  final user = ParseUser(username, password, null);
  final response = await user.login();
  if (response.success) {
    print('User logged in: ${response.result}');
  } else {
    print('Login error: ${response.error?.message}');
  }
}
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';

Future<void> signUpUser(String username, String password, String email) async {
  final user = ParseUser(username, password, email);
  final response = await user.signUp();
  if (response.success) {
    print('User signed up successfully!');
  } else {
    print('Sign up error: ${response.error?.message}');
  }
}

Future<void> logInUser(String username, String password) async {
  final user = ParseUser(username, password, null);
  final response = await user.login();
  if (response.success) {
    print('User logged in: ${response.result}');
  } else {
    print('Login error: ${response.error?.message}');
  }
}
﻿
Soziale Anmeldung
Back4app unterstützt Integrationen mit Google, Apple, Facebook und mehr. Jeder Anbieter hat einen spezifischen Ansatz und benötigt möglicherweise zusätzliche Bibliotheken (z. B. für Facebook- oder Google-Anmeldung). Sie können dann aufrufen:
Dart
await ParseUser.loginWith('facebook', <String, dynamic>{
  'id': 'USER_FACEBOOK_ID',
  'access_token': 'FACEBOOK_ACCESS_TOKEN',
  'expiration_date': 'DATE'
});
await ParseUser.loginWith('facebook', <String, dynamic>{
  'id': 'USER_FACEBOOK_ID',
  'access_token': 'FACEBOOK_ACCESS_TOKEN',
  'expiration_date': 'DATE'
});
﻿
Passen Sie die Parameter gemäß der Dokumentation des Anbieters an.
Schritt 6 – Umgang mit Dateispeicherung
Einrichten der Dateispeicherung
Sie können Bilder, Dokumente oder andere Mediendateien mit ParseFile. Back4app sichert diese Dateien und stellt eine URL für den Abruf zur Verfügung.
Dart
import 'dart:io';
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:image_picker/image_picker.dart';

Future<void> uploadImage() async {
  final picker = ImagePicker();
  final XFile? pickedFile = await picker.pickImage(source: ImageSource.gallery);
  if (pickedFile == null) {
    print('No file selected.');
    return;
  }

  final parseFile = ParseFile(File(pickedFile.path));
  final response = await parseFile.save();
  if (response.success) {
    print('File saved: ${parseFile.url}');
  } else {
    print('Error uploading file: ${response.error?.message}');
  }
}
import 'dart:io';
import 'package:parse_server_sdk_flutter/parse_server_sdk_flutter.dart';
import 'package:image_picker/image_picker.dart';

Future<void> uploadImage() async {
  final picker = ImagePicker();
  final XFile? pickedFile = await picker.pickImage(source: ImageSource.gallery);
  if (pickedFile == null) {
    print('No file selected.');
    return;
  }

  final parseFile = ParseFile(File(pickedFile.path));
  final response = await parseFile.save();
  if (response.success) {
    print('File saved: ${parseFile.url}');
  } else {
    print('Error uploading file: ${response.error?.message}');
  }
}
﻿
Sicherheitsüberlegungen
Sie können definieren, wer Zugriff auf Dateien hat (öffentlich, authentifizierte Benutzer oder eingeschränkt), indem Sie die Dateisicherheit mit ACLs kombinieren. Dies stellt sicher, dass Ihre Dateidaten sicher bleiben.
Schritt 7 – E-Mail-Verifizierung und Passwortzurücksetzung
Warum sie wichtig sind
Die E-Mail-Verifizierung bestätigt, dass ein Benutzer die angegebene E-Mail-Adresse besitzt, während die Passwortzurücksetzungsabläufe die Benutzererfahrung und Sicherheit verbessern.
Dashboard-Konfiguration
Gehe zu den E-Mail-Einstellungen deiner App im Back4app-Dashboard.
Aktiviere E-Mail-Verifizierung und Passwortzurücksetzung.
Konfiguriere E-Mail-Vorlagen oder deine benutzerdefinierte Domain, falls erforderlich.
Diese Einstellungen ermöglichen es deiner Flutter-App, automatisch Benutzerbesitzprüfungen und Passwortwiederherstellungen durchzuführen.
Implementierung in Flutter
Dart
final user = ParseUser('testuser', 'password123', '[email protected]');
final signUpResponse = await user.signUp();
if (signUpResponse.success) {
  // The user will receive a verification email
}

// For password reset
final resetResponse = await ParseUser.requestPasswordReset('[email protected]');
if (resetResponse.success) {
  print('Reset email sent successfully!');
}
final user = ParseUser('testuser', 'password123', 'test@example.com');
final signUpResponse = await user.signUp();
if (signUpResponse.success) {
  // The user will receive a verification email
}

// For password reset
final resetResponse = await ParseUser.requestPasswordReset('test@example.com');
if (resetResponse.success) {
  print('Reset email sent successfully!');
}
﻿
Schritt 8 – Aufgaben mit Cloud-Jobs planen
Cloud-Jobs
Du möchtest möglicherweise wiederkehrende Aufgaben planen (wie das Bereinigen alter Daten oder das Senden regelmäßiger E-Mails). Cloud-Jobs ermöglichen dir genau das:
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);
  const oldTodos = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
  return `Deleted ${oldTodos.length} old Todos.`;
});
// 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);
  const oldTodos = await query.find({ useMasterKey: true });
  await Parse.Object.destroyAll(oldTodos, { useMasterKey: true });
  return `Deleted ${oldTodos.length} old Todos.`;
});
﻿
Stellen Sie diesen Code bereit, gehen Sie dann zu App-Einstellungen > Servereinstellungen > Hintergrundjobs in Ihrem Back4app-Dashboard, um ihn zu planen.
Planung eines Cloud-Jobs
﻿
Schritt 9 – Integration von Webhooks
Was sind Webhooks?
Webhooks ermöglichen es Ihrer Back4app-App, HTTP-Anfragen an einen externen Dienst zu senden, wenn bestimmte Ereignisse eintreten (z. B. das Speichern eines neuen Objekts). Dies ist ideal für die Integration mit Drittanbieter-Tools.
Gehen Sie zu Mehr > WebHooks in Ihrem Back4app-Dashboard und Webhook hinzufügen.
Legen Sie Ihren Endpunkt und die Trigger fest (z. B. „Neuer Datensatz in Todo“).
Hinzufügen eines Webhooks
﻿
Sie können Webhooks auch manuell im Cloud-Code konfigurieren, indem Sie HTTP-Anfragen in beforeSave- oder afterSave-Triggern durchführen.
BeforeSave WebHook
﻿
Schritt 10 – Erkundung des Back4App Admin Panels
Wo man es findet
Die Back4app Admin App ist eine benutzerfreundliche Oberfläche, die es nicht-technischen Teammitgliedern ermöglicht, Daten (CRUD-Operationen, Datenaufgaben usw.) zu verwalten, ohne das Parse Dashboard öffnen zu müssen.
Gehe zu App Dashboard > Mehr > Admin App.
Klicke auf Admin App aktivieren.
Admin App aktivieren
﻿
Du wirst einen Admin-Benutzer erstellen, eine Subdomain wählen und dich mit den neu erstellten Anmeldeinformationen anmelden. Die Admin App hilft bei schnellen Datenüberprüfungen und -änderungen.
Fazit
In diesem Tutorial haben Sie gelernt wie man ein Backend für Flutter mit Back4app und dem Parse Flutter SDK erstellt. 
Sie haben Klassen erstellt, Daten gespeichert, Echtzeitanfragen konfiguriert, Sicherheit mit ACLs und CLPs angewendet, Cloud-Funktionen geschrieben, Aufgaben geplant, Webhooks integriert und das Back4app Admin Panel erkundet. 
Dieser Ansatz beschleunigt die Entwicklung, indem er Ihnen ermöglicht, sich auf die Flutter-Client-Seite zu konzentrieren, anstatt auf eine komplexe Serverkonfiguration.
Der endgültige String, den Sie jetzt haben, ist ein funktionierendes und sicheres Backend, das auf RESTful-APIs, Benutzerauthentifizierung und einfacher Datenmanipulation basiert. 
Sie können jederzeit fortgeschrittenere Funktionen integrieren – wie zusätzliche Cloud-Funktionen, externe API-Aufrufe oder benutzerdefinierte Rollen. 
Nächste Schritte
Gehen Sie in die Produktion: Implementieren Sie fortgeschrittenes Caching, Analytik oder rollenbasierte Zugriffskontrollen.
Erweitern Sie Ihre App: Integrieren Sie Drittanbieterdienste oder erstellen Sie weitere Cloud-Funktionen für spezialisierte Geschäftslogik.
Konsultieren Sie die Back4app-Dokumentation: Erkunden Sie fortgeschrittene Sicherheit, Leistungsoptimierung, Protokollanalyse und mehr.
Erfahren Sie mehr: Schauen Sie sich Tutorials für Live-Chat-Apps, standortbasierte Dienste oder komplexere Datenstrukturen an. Kombinieren Sie diese mit Ihrem Flutter-Projekt für reale Anwendungsfälle.
Durch die kontinuierliche Verfeinerung dieses Setups werden Sie Ihre Flutter-App in eine leistungsstarke, skalierbare Lösung verwandeln, die auf einem robusten Backend-Dienst basiert. Viel Spaß beim Programmieren!
Aktualisiert 23 Jan 2025
Hat Ihnen diese Seite geholfen?
Wie man ein Backend für Objective-C erstellt?
ALS NÄCHSTES
Wie man ein Backend für Gatsby erstellt?