Schnellstarter
Wie man ein Backend für MacOS erstellt?

45min
Einführung
In diesem Tutorial lernen Sie wie man ein Backend für MacOS mit Back4app und dem Parse Swift SDK erstellt. 
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 Ihrer MacOS-Anwendung 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 macOS-Anwendung zu erweitern oder bei Bedarf benutzerdefinierte Logik und Drittanbieter-APIs einfach zu integrieren.
Die Beherrschung dieses Ansatzes wird Ihnen ermöglichen, Ihre Arbeitsabläufe zu optimieren und zu lernen, wie man schnell und effizient ein Backend für MacOS erstellt.
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. Folgen Sie der obigen Anleitung, um Ihr Projekt vorzubereiten.
Eine macOS-Entwicklungsumgebung (Xcode)
Sie können Xcode aus dem Mac App Store installieren.
Swift Package Manager oder CocoaPods
Zum Installieren des Parse Swift SDK. Parse Swift Dokumentation.﻿
Grundkenntnisse in Swift und der Entwicklung von macOS-Anwendungen
Offizielle Dokumentation von Apple
Vertrautheit mit SwiftUI oder AppKit ist hilfreich.
Stellen Sie sicher, dass Sie alle diese Voraussetzungen erfüllt haben, bevor Sie beginnen. Ihr Back4app-Projekt eingerichtet und Ihre lokale macOS-Entwicklungsumgebung bereit zu haben, wird Ihnen helfen, leichter folgen zu können.
Schritt 1 – Einrichten des Back4app-Projekts
Ein neues Projekt erstellen
Der erste Schritt beim Erstellen Ihres macOS-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. „macOS-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 Swift SDK
Back4app basiert auf der Parse-Plattform, um Ihre Daten zu verwalten, Echtzeitfunktionen bereitzustellen, die Benutzerauthentifizierung zu handhaben und mehr. Die Verbindung Ihrer macOS-Anwendung mit Back4app umfasst die Installation des Parse Swift SDK und die Initialisierung mit den Anmeldeinformationen aus Ihrem Back4app-Dashboard.
Holen Sie sich Ihre Parse-Schlüssel:
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 clientKey) zu finden. Sie finden auch die Parse-Server-URL (häufig im Format https://parseapi.back4app.com).
﻿
Installieren Sie das Parse Swift SDK in Ihrem macOS-Projekt:
Wenn Sie Swift Package Manager:
Swift
dependencies: [
    .package(url: "https://github.com/netreconlab/Parse-Swift.git", from: "5.0.0")
]
dependencies: [
    .package(url: "https://github.com/netreconlab/Parse-Swift.git", from: "5.0.0")
]
﻿
Wenn Sie CocoaPods, fügen Sie dies zu Ihrer Podfile:
Ruby
pod 'ParseSwiftOG'
pod 'ParseSwiftOG'
﻿
Initialisieren Sie Parse in Ihrer macOS-Anwendung (zum Beispiel in AppDelegate.swift wenn Sie AppKit verwenden, oder in einer SwiftUI @main Struktur, wenn Sie eine SwiftUI-App erstellen):
Swift
import ParseSwift
import SwiftUI

@main
struct MyMacOSApp: App {
    init() {
        Task {
            do {
                try await ParseSwift.initialize(
                    applicationId: "YOUR_APPLICATION_ID",
                    clientKey: "YOUR_CLIENT_KEY",
                    serverURL: URL(string: "https://parseapi.back4app.com")!
                )
            } catch {
                print("Error initializing Parse: \(error)")
            }
        }
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
import ParseSwift
import SwiftUI

@main
struct MyMacOSApp: App {
    init() {
        Task {
            do {
                try await ParseSwift.initialize(
                    applicationId: "YOUR_APPLICATION_ID",
                    clientKey: "YOUR_CLIENT_KEY",
                    serverURL: URL(string: "https://parseapi.back4app.com")!
                )
            } catch {
                print("Error initializing Parse: \(error)")
            }
        }
    }

    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}
﻿
Durch das Abschließen dieses Schrittes haben Sie eine sichere Verbindung zwischen Ihrem macOS-Frontend (UI) 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 – Einrichten der Datenbank
Speichern und Abfragen von Daten
Mit Ihrem Back4app-Projekt, das eingerichtet und das Parse Swift SDK in Ihre macOS-App integriert ist, können Sie nun mit dem Speichern und Abrufen von Daten beginnen. Der einfachste Weg, ein Objekt zu erstellen, besteht darin, eine Struktur zu definieren, die ParseObject implementiert, und dann save() aufzurufen.
Swift
struct Todo: ParseObject {
    // ParseObject required properties
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    // Custom properties
    var title: String?
    var isCompleted: Bool?
}

func createTodoItem(title: String, isCompleted: Bool) async {
    var todo = Todo()
    todo.title = title
    todo.isCompleted = isCompleted
    do {
        try await todo.save()
        print("Todo saved successfully.")
    } catch {
        print("Error saving Todo: \(error)")
    }
}

func fetchTodos() async -> [Todo] {
    let query = Todo.query()
    do {
        return try await query.find()
    } catch {
        print("Error fetching Todos: \(error)")
        return []
    }
}
struct Todo: ParseObject {
    // ParseObject required properties
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?

    // Custom properties
    var title: String?
    var isCompleted: Bool?
}

func createTodoItem(title: String, isCompleted: Bool) async {
    var todo = Todo()
    todo.title = title
    todo.isCompleted = isCompleted
    do {
        try await todo.save()
        print("Todo saved successfully.")
    } catch {
        print("Error saving Todo: \(error)")
    }
}

func fetchTodos() async -> [Todo] {
    let query = Todo.query()
    do {
        return try await query.find()
    } catch {
        print("Error fetching Todos: \(error)")
        return []
    }
}
﻿
Alternativ können Sie die REST- oder GraphQL-API 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 '{"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 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
    }
  }
}
﻿
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 Swift 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 unterstützt verschiedene Datentypen: String, Zahl, Boolean, Objekt, Datum, Datei, Zeiger, Array, Relation, GeoPoint, und Polygon. Sie können den geeigneten Typ für jedes Feld auswählen oder Parse automatisch diese Spalten erstellen lassen, wenn Sie zum ersten Mal ein Objekt aus Ihrer macOS-App speichern.
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 bei Back4app 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 Category-Objekt, das auf mehrere Todo-Elemente verweist—können Sie Pointers oder Relations in Parse Swift verwenden:
Swift
struct Category: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    // Custom fields
    var name: String?
}

struct Todo: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    var title: String?
    var category: Pointer<Category>?
}

func createTaskForCategory(categoryObjectId: String, title: String) async {
    let pointer = Pointer<Category>(objectId: categoryObjectId)
    var todo = Todo()
    todo.title = title
    todo.category = pointer
    do {
        try await todo.save()
        print("Todo linked to category")
    } catch {
        print("Error creating Task with category relationship: \(error)")
    }
}

func fetchTodosWithCategory() async {
    let query = Todo.query().include("category")
    do {
        let todos = try await query.find()
        print("Fetched Todo items with Category: \(todos)")
    } catch {
        print("Error fetching Todos: \(error)")
    }
}
struct Category: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    // Custom fields
    var name: String?
}

struct Todo: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    var title: String?
    var category: Pointer<Category>?
}

func createTaskForCategory(categoryObjectId: String, title: String) async {
    let pointer = Pointer<Category>(objectId: categoryObjectId)
    var todo = Todo()
    todo.title = title
    todo.category = pointer
    do {
        try await todo.save()
        print("Todo linked to category")
    } catch {
        print("Error creating Task with category relationship: \(error)")
    }
}

func fetchTodosWithCategory() async {
    let query = Todo.query().include("category")
    do {
        let todos = try await query.find()
        print("Fetched Todo items with Category: \(todos)")
    } catch {
        print("Error fetching Todos: \(error)")
    }
}
﻿
Live-Abfragen
Für Echtzeit-Updates bietet Back4app Live Queries. Durch Aktivieren von Live Queries in Ihrem Back4app-Dashboard können Sie Änderungen in einer bestimmten Klasse von Ihrer macOS-App aus abonnieren.
Aktivieren Sie Live Queries in Ihrem Back4app-Dashboard unter den Servereinstellungen Ihrer App.
Initialisieren Sie Live Queries im Code (der Swift Live Query-Client ist noch in der Entwicklung, aber Sie können community-gesteuerte Ansätze verwenden oder auf offizielle Parse Swift-Updates warten).
src/parseConfig.swift
// Example (subject to support in Parse Swift):
// Live Query’s subdomain:
// ParseSwift.configuration.liveQueryServerURL = URL(string: "wss://YOUR_SUBDOMAIN_HERE.b4a.io")!
// Example (subject to support in Parse Swift):
// Live Query’s subdomain:
// ParseSwift.configuration.liveQueryServerURL = URL(string: "wss://YOUR_SUBDOMAIN_HERE.b4a.io")!
﻿
Sobald Sie abonniert sind, erhalten Sie Benachrichtigungen, wann immer ein neues Todo erstellt, aktualisiert oder gelöscht wird. Dies ist besonders wertvoll für kollaborative oder hochinteraktive Desktop-Apps, bei denen mehrere Benutzer oder Prozesse die neuesten Daten sofort sehen müssen.
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, wenn Ihre macOS-App ein Konzept von „privaten Aufgaben“ für den aktuell angemeldeten Benutzer hat:
Swift
import ParseSwift

func createPrivateTodo(title: String) async {
    guard let currentUser = User.current else { return }

    var todo = Todo()
    todo.title = title

    // Create an ACL granting read/write access only to the owner
    var acl = ParseACL()
    acl.setReadAccess(currentUser, value: true)
    acl.setWriteAccess(currentUser, value: true)

    todo.ACL = acl

    do {
        try await todo.save()
        print("Private Todo saved")
    } catch {
        print("Error saving private Todo: \(error)")
    }
}
import ParseSwift

func createPrivateTodo(title: String) async {
    guard let currentUser = User.current else { return }

    var todo = Todo()
    todo.title = title

    // Create an ACL granting read/write access only to the owner
    var acl = ParseACL()
    acl.setReadAccess(currentUser, value: true)
    acl.setWriteAccess(currentUser, value: true)

    todo.ACL = acl

    do {
        try await todo.save()
        print("Private Todo saved")
    } catch {
        print("Error saving private Todo: \(error)")
    }
}
﻿
Wenn Sie das Objekt speichern, hat es eine ACL, die verhindert, dass jemand außer dem angegebenen Benutzer es lesen oder ändern kann.
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-Bereich.
Wähle eine Klasse (z.B. „Todo“).
Öffne die Klassenberechtigungen-Registerkarte.
Konfiguriere deine Standardeinstellungen, wie „Benötigt Authentifizierung“ für Lesen oder Schreiben oder „Kein Zugriff“ für die Öffentlichkeit.
﻿
Schritt 4 – Schreiben und Bereitstellen von Cloud-Funktionen
Cloud Code ist eine Funktion der Parse Server-Umgebung, die es dir ermöglicht, benutzerdefinierten JavaScript-Code auf der Serverseite auszuführen – ohne dass du deine eigenen Server oder Infrastruktur verwalten musst. Durch das Schreiben von Cloud Code kannst du dein Back4app-Backend mit zusätzlicher Geschäftslogik, Validierungen, Triggern und Integrationen erweitern, die sicher und effizient auf dem Parse Server ausgeführt werden.
Wie es funktioniert
Wenn du Cloud Code schreibst, platzierst du typischerweise deine JavaScript-Funktionen, Trigger und alle erforderlichen NPM-Module in einer main.js-Datei. Du stellst diese Datei dann in deinem Back4app-Projekt bereit, und sie wird in der Parse Server-Umgebung ausgeführt. Dies ermöglicht es dir, sensible Logik serverseitig zu halten.
Typische Anwendungsfälle:
Geschäftslogik: Berechnungen oder Transformationen vor dem Speichern von Daten
Datenvalidierungen: Sicherstellen, dass bestimmte Felder Kriterien erfüllen
Trigger: Aktionen ausführen, wenn sich Daten ändern
Integrationen: Verbindung mit externen APIs (z.B. Zahlungen, Benachrichtigungen)
Beispiel-Funktion
JS
// main.js
Parse.Cloud.define('calculateTextLength', async (request) => {
  const { text } = request.params;
  if (!text) {
    throw new Error('No text provided');
  }
  return { length: text.length };
});
// main.js
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
Installieren Sie die CLI:
Bash
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash
curl https://raw.githubusercontent.com/back4app/parse-cli/back4app/installer.sh | sudo /bin/bash
﻿
Konfigurieren Sie Ihren Kontoschlüssel:
Bash
b4a configure accountkey
b4a configure accountkey
﻿
Bereitstellen Sie Ihren Cloud-Code:
Bash
b4a deploy
b4a deploy
﻿
Aufrufen Ihrer Funktion
Von macOS aus mit Swift:
Swift
import ParseSwift

func getTextLength(text: String) async {
    do {
        let result = try await ParseCloud.callFunction("calculateTextLength", with: ["text": text])
        if let resultDict = result as? [String: Any],
           let length = resultDict["length"] as? Int {
            print("Text length: \(length)")
        }
    } catch {
        print("Error calling cloud function: \(error)")
    }
}
import ParseSwift

func getTextLength(text: String) async {
    do {
        let result = try await ParseCloud.callFunction("calculateTextLength", with: ["text": text])
        if let resultDict = result as? [String: Any],
           let length = resultDict["length"] as? Int {
            print("Text length: \(length)")
        }
    } catch {
        print("Error calling cloud function: \(error)")
    }
}
﻿
Sie können es auch über REST oder GraphQL aufrufen, genau wie in anderen Frameworks.
Schritt 5 – Konfigurieren der Benutzerauthentifizierung
Benutzerauthentifizierung in Back4app
Back4app nutzt die ParseUser Klasse als Grundlage für die Authentifizierung. Standardmäßig kümmert sich Parse um die Passwort-Hashing, Sitzungstoken und sichere Speicherung, sodass Sie keine komplexen Sicherheitsabläufe manuell einrichten müssen.
Einrichten der Benutzerauthentifizierung
In einer macOS-Anwendung können Sie einen neuen Benutzer mit folgendem erstellen:
Swift
struct User: ParseUser {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    // Default properties
    var username: String?
    var email: String?
    var emailVerified: Bool?
    var password: String?
    var authData: [String : [String : String]?]?
}

func signUpUser(username: String, password: String, email: String) async {
    var newUser = User()
    newUser.username = username
    newUser.password = password
    newUser.email = email
    do {
        newUser = try await newUser.signUp()
        print("User signed up successfully!")
    } catch {
        print("Error signing up user: \(error)")
    }
}

func logInUser(username: String, password: String) async {
    do {
        let user = try await User.login(username: username, password: password)
        print("User logged in: \(user)")
    } catch {
        print("Error logging in user: \(error)")
    }
}
struct User: ParseUser {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    // Default properties
    var username: String?
    var email: String?
    var emailVerified: Bool?
    var password: String?
    var authData: [String : [String : String]?]?
}

func signUpUser(username: String, password: String, email: String) async {
    var newUser = User()
    newUser.username = username
    newUser.password = password
    newUser.email = email
    do {
        newUser = try await newUser.signUp()
        print("User signed up successfully!")
    } catch {
        print("Error signing up user: \(error)")
    }
}

func logInUser(username: String, password: String) async {
    do {
        let user = try await User.login(username: username, password: password)
        print("User logged in: \(user)")
    } catch {
        print("Error logging in user: \(error)")
    }
}
﻿
Über REST könnte ein Login 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 einem erfolgreichen Login erstellt Parse ein Sitzungstoken. Sie können auf den aktuell angemeldeten Benutzer zugreifen:
Swift
if let currentUser = User.current {
    print("Currently logged-in user: \(currentUser.username ?? "No username")")
} else {
    print("No user is logged in")
}
if let currentUser = User.current {
    print("Currently logged-in user: \(currentUser.username ?? "No username")")
} else {
    print("No user is logged in")
}
﻿
Abmelden:
Swift
do {
    try await User.logout()
} catch {
    print("Error logging out: \(error)")
}
do {
    try await User.logout()
} catch {
    print("Error logging out: \(error)")
}
﻿
Integration von sozialem Login
Sie können beliebte Anbieter wie Google, Apple oder Facebook integrieren, indem Sie authData. Detaillierte Anweisungen variieren, daher beziehen Sie sich auf Dokumentation zum sozialen Login.﻿
E-Mail-Verifizierung und Passwortzurücksetzung
Um die E-Mail-Verifizierung und das Zurücksetzen des Passworts zu aktivieren:
Navigieren Sie zu den E-Mail-Einstellungen in Ihrem Back4app-Dashboard.
Aktivieren Sie die E-Mail-Verifizierung.
Konfigurieren Sie die Absenderadresse, E-Mail-Vorlagen und Ihre benutzerdefinierte Domain, falls gewünscht.
Dies verbessert die Kontosicherheit, indem Benutzer-E-Mails validiert und eine Methode zur Passwortwiederherstellung bereitgestellt wird.
Schritt 6 – Umgang mit Dateispeicher
Hochladen und Abrufen von Dateien
Parse enthält die ParseFile-Klasse zum Verarbeiten von Datei-Uploads, die Back4app sicher speichert:
Swift
func uploadFile(data: Data) async -> ParseFile? {
    let file = ParseFile(name: "doc.txt", data: data)
    do {
        let savedFile = try await file.save()
        print("File saved:", savedFile.url ?? "No URL")
        return savedFile
    } catch {
        print("Error uploading file:", error)
        return nil
    }
}
func uploadFile(data: Data) async -> ParseFile? {
    let file = ParseFile(name: "doc.txt", data: data)
    do {
        let savedFile = try await file.save()
        print("File saved:", savedFile.url ?? "No URL")
        return savedFile
    } catch {
        print("Error uploading file:", error)
        return nil
    }
}
﻿
Fügen Sie es einem Objekt hinzu:
Swift
struct Photo: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    var imageFile: ParseFile?
}

func createPhotoObject(file: ParseFile) async {
    var photo = Photo()
    photo.imageFile = file
    do {
        try await photo.save()
        print("Photo object saved!")
    } catch {
        print("Error saving photo:", error)
    }
}
struct Photo: ParseObject {
    var objectId: String?
    var createdAt: Date?
    var updatedAt: Date?
    var ACL: ParseACL?
    var originalData: Data?
    var imageFile: ParseFile?
}

func createPhotoObject(file: ParseFile) async {
    var photo = Photo()
    photo.imageFile = file
    do {
        try await photo.save()
        print("Photo object saved!")
    } catch {
        print("Error saving photo:", error)
    }
}
﻿
Dateisicherheit
Sie können die Sicherheit des Datei-Uploads in den Einstellungen Ihres Parse Servers konfigurieren. Zum Beispiel, welche Benutzer Dateien hochladen oder löschen können. Bedenken Sie, dass, wenn Sie die URL der Datei teilen, jeder mit dieser URL darauf zugreifen kann, es sei denn, Sie haben strengere serverseitige Regeln festgelegt.
Schritt 7 – E-Mail-Verifizierung und Passwortzurücksetzung
Übersicht
E-Mail-Verifizierung und Passwortzurücksetzungen sind entscheidend für eine sichere Benutzerverwaltung. Wir haben bereits in Schritt 5, darauf hingewiesen, aber zur Erinnerung:
Aktivieren Sie diese Funktionen im Back4app Dashboard (E-Mail-Einstellungen).
Konfigurieren Sie die E-Mail-Vorlagen „E-Mail-Verifizierung aktivieren“ und „Passwort zurücksetzen“. 
Testen Sie den Ablauf von Ihrer macOS-App.
Schritt 8 – Aufgaben mit Cloud-Jobs planen
Cloud-Jobs
Cloud-Jobs ermöglichen es Ihnen, routinemäßige Aufgaben in Ihrem Backend zu planen und auszuführen, wie das Senden von regelmäßigen E-Mails oder das Bereinigen von Daten. Zum Beispiel:
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 Ihren Cloud-Code bereit mit dem neuen Job.
Gehen Sie zum Back4app-Dashboard > App-Einstellungen > Servereinstellungen > Hintergrundjobs.
Planen Sie den Job (z. B. täglich).
Planung eines Cloud-Jobs
﻿
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. Dies ist leistungsstark für die Integration mit Drittanbietersystemen wie Zahlungs-Gateways, E-Mail-Marketing-Tools oder Analyseplattformen.
Navigieren Sie zur Webhook-Konfiguration in Ihrem Back4app-Dashboard > Mehr > WebHooks.
Richten Sie einen Endpunkt ein (z. B. https://your-external-service.com/webhook-endpoint).
Konfigurieren Sie Trigger um anzugeben, welche Ereignisse in Ihren Back4app-Klassen oder Cloud-Code-Funktionen den Webhook auslösen.
Hinzufügen eines Webhooks
﻿
Wenn Sie beispielsweise Slack benachrichtigen möchten, wann immer ein neues Todo erstellt wird:
Erstellen Sie eine Slack-App, die eingehende Webhooks akzeptiert.
Kopieren Sie die Slack-Webhook-URL.
Setzen Sie in Ihrem Back4app-Dashboard den Endpunkt auf diese Slack-URL für das Ereignis „Neuer Datensatz in der Todo-Klasse.“
Schritt 10 – Erkundung des Back4app-Admin-Panels
Die Back4app Admin App ist eine webbasierte Verwaltungsoberfläche, die für nicht-technische Benutzer entwickelt wurde, um CRUD-Operationen durchzuführen und routinemäßige Datenaufgaben ohne Programmierung zu erledigen. Sie bietet eine modellzentrierte, benutzerfreundliche Oberfläche, die die Datenbankverwaltung, das benutzerdefinierte Datenmanagement und betriebliche Abläufe auf Unternehmensebene optimiert.
Aktivierung der Admin App
Aktivieren Sie es, indem Sie zu App-Dashboard > Mehr > Admin App gehen und auf „Admin App aktivieren“ klicken.
Admin App aktivieren
﻿
Erstellen Sie einen ersten Admin-Benutzer, der automatisch eine neue Rolle (B4aAdminUser) und relevante Klassen im Schema Ihrer App generiert.
﻿
Wählen Sie eine Subdomain für den Zugriff auf die Admin-Oberfläche und schließen Sie die Einrichtung ab.
﻿
Einloggen mit den Admin-Anmeldeinformationen, die Sie erstellt haben, um auf Ihr neues Admin App-Dashboard zuzugreifen.
﻿
Sobald aktiviert, ermöglicht die Back4app Admin App eine einfache Ansicht, Bearbeitung oder Entfernung von Datensätzen aus Ihrer Datenbank – ohne direkte Nutzung des Parse Dashboards oder Backend-Codes.
Fazit
Durch das Befolgen dieses umfassenden Tutorials haben Sie:
Ein sicheres Backend für eine macOS-App auf Back4app erstellt.
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 Funktionen implementiert, um benutzerdefinierte Geschäftslogik auf der Serverseite auszuführen.
Benutzerauthentifizierung eingerichtet mit Unterstützung für E-Mail-Verifizierung 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 macOS-Frontend und einem robusten Back4app-Backend sind Sie nun gut gerüstet, um funktionsreiche, skalierbare und sichere Desktop-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.
Nächste Schritte
Erstellen Sie eine produktionsbereite macOS-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 Echtzeitkommunikation, IoT-Dashboards oder standortbasierten Diensten. Kombinieren Sie die hier erlernten Techniken mit Drittanbieter-APIs, um komplexe, reale Anwendungen zu erstellen.
﻿
Aktualisiert 23 Jan 2025
Hat Ihnen diese Seite geholfen?
Wie man ein Backend für tvOS erstellt?
ALS NÄCHSTES
Wie man ein Backend für iOS erstellt?