Wie erstellt man ein Backend für seine iOS App?

iOS-Apps benötigen ebenso wie Webanwendungen eine Möglichkeit, Daten zu speichern und zu verfolgen. Unabhängig davon, ob diese Daten auf einem Cloud-Backend-Dienst oder einem lokal erstellten, persönlich betriebenen Server gespeichert werden, ist ein Backend für die Verwaltung von Benutzerdaten unerlässlich.

Ein Backend für Ihre iOS-App von Grund auf zu erstellen, kann jedoch eine entmutigende Aufgabe sein, vor allem, wenn Sie in der Regel neu in der iOS-Entwicklung und Backend-Entwicklung sind.

In diesem Lernprogramm lernen Sie, wie Sie ein Backend für Ihre iOS-App erstellen. Zunächst geben wir einen Überblick über die iOS-Entwicklung und diskutieren ihre Vorteile und Grenzen.

Dann lernen Sie die verschiedenen Backend-Optionen kennen, die Ihnen zur Verfügung stehen. Schließlich erfahren Sie, wie Sie Back4App, ein Backend as a Service (BaaS), als Backend für Ihre iOS-App verwenden können.

iOS-Übersicht

Apple hat iOS als primäres Betriebssystem für die mobilen Anwendungen entwickelt, die auf seinen iPhones, iPads und iPod Touch-Geräten laufen.

Die Entwicklung dieser Apps und ihre Optimierung für die von Apple konzipierte iOS-Plattform wird als iOS-Entwicklung bezeichnet. iOS-Apps werden in zwei Programmiersprachen geschrieben, nämlich in Objective-C und neuerdings in Swift.

Objective-C war vor der Einführung von Swift im Jahr 2014 die wichtigste Sprache für die Entwicklung von iOS-Apps. Swift wurde als modernere und benutzerfreundlichere Sprache entwickelt, mit Funktionen wie Typinferenz und Optionals, die das Lesen und Schreiben erleichtern.

Beide Sprachen können in demselben Projekt verwendet werden. Dies liegt daran, dass Swift laut der Swift-Dokumentation so konzipiert wurde, dass es mit Objective-C kompatibel ist und zur Interaktion mit bestehendem Objective-C-Legacy-Code verwendet werden kann.

Für die Erstellung von iOS-Apps stellt Apple Xcode zur Verfügung, eine integrierte Entwicklungsumgebung (IDE), mit der Sie bequem Code schreiben, iOS-Apps erstellen und entwickeln können.

Vorteile der Entwicklung von iOS-Anwendungen

Als Entwickler kann die Entwicklung von iOS-Apps auf folgende Weise von Vorteil sein:

Hochwertiges Benutzererlebnis

iOS-Apps sind für ihre außergewöhnliche Benutzerfreundlichkeit bekannt, mit intuitivem und ausgefeiltem Design, das die Benutzer attraktiv und einfach zu bedienen finden.

Sie haben eine spezielle Richtlinie für das App-Design entwickelt, die für ein optimales Benutzererlebnis sorgt und den Schwerpunkt auf Einfachheit, Klarheit und Konsistenz legt. Das Ergebnis sind visuell ansprechende Apps mit Bedienelementen und Layouts, die es den Nutzern leicht machen, das zu finden, was sie brauchen, und ihre Aufgaben schnell zu erledigen.

Darüber hinaus stellt Apple den Entwicklern umfassende Design-Werkzeuge und -Ressourcen zur Verfügung, um sicherzustellen, dass ihre Anwendungen den höchsten Qualitätsstandards entsprechen.

iOS-Apps sind außerdem für die spezifische Hardware und Software von Apple-Geräten optimiert, was zu einer schnellen Leistung, flüssigen Animationen und hochwertigen Grafiken führt.

Mehr Sicherheit

Ein weiterer großer Vorteil von iOS-Anwendungen ist das hohe Maß an Sicherheit, das sie bieten. Dies ist auf mehrere Faktoren zurückzuführen, vor allem auf das strenge Prüfverfahren im App Store von Apple, die starke Verschlüsselung und die auf den Datenschutz ausgerichteten Funktionen.

Der App Store-Überprüfungsprozess soll sicherstellen, dass alle App Store-Apps strenge Inhalts- und Sicherheitsrichtlinien erfüllen. Dazu gehört auch die Überprüfung auf bösartigen Code, Malware und andere potenzielle Sicherheitsbedrohungen.

Daher ist es weniger wahrscheinlich, dass iOS-Apps schädlichen Code enthalten oder für Phishing-Angriffe oder andere bösartige Aktivitäten verwendet werden.

Konsistenz über alle Geräte hinweg

iOS-Apps sind so konzipiert, dass sie auf allen Apple-Geräten, einschließlich iPhones, iPads und iPod Touches, gleich aussehen und funktionieren.

Diese Konsistenz macht es den Nutzern leicht, zwischen verschiedenen Geräten zu wechseln, ohne dass sie eine neue Benutzeroberfläche oder ein neues Navigationssystem lernen müssen. Sie stellt auch sicher, dass App-Entwickler Apps entwerfen und erstellen können, die nahtlos auf allen Geräten funktionieren, ohne sich um Kompatibilitätsprobleme oder gerätespezifische Funktionen kümmern zu müssen.

Entwickler-Tools

Apple stellt iOS-Entwicklern leistungsstarke Werkzeuge zur Verfügung, die das Entwickeln, Testen und Debuggen von iOS-Apps erleichtern.

Zu diesen Tools gehören das iOS SDK, Xcode und eine Reihe anderer Tools und Ressourcen, mit denen sich die Erfahrung der Entwickler und die Qualität der erstellten Apps optimieren lassen.

Beschränkungen bei der Entwicklung von iOS-Anwendungen

Die iOS-Entwicklungserfahrung ist nicht makellos. Es gibt Einschränkungen, die Sie bei der Entwicklung einer iOS-App erfahren werden. Einige von ihnen sind.

Eingeschränkte Gerätekompatibilität

Ein großes Ärgernis bei der Entwicklung von iOS-Apps ist die geringe Kompatibilität der Geräte. In der heutigen Welt gibt es eine Vielzahl von Herstellern mobiler Geräte und eine ebenso große Zahl von Nutzern.

Allerdings laufen iOS-Anwendungen nur auf Apples eigener Hardware. Das bedeutet, dass die Apps nur auf dem iPhone, dem iPad und dem iPod Touch verwendet werden können. Dies schränkt die potenzielle Zielgruppe für eine von Ihnen entwickelte App ein und beschränkt sie auf das Apple-Ökosystem.

Apple hat zwar eine große Nutzerbasis, aber die begrenzte Gerätekompatibilität von iOS-Anwendungen kann ein Nachteil sein, wenn Sie ein größeres Publikum außerhalb von Apple erreichen wollen.

App Store Genehmigungsprozess

Das Überprüfungsverfahren im App Store von Apple ist bekannt dafür, dass es streng ist und länger dauern kann als in anderen App Stores, wie z. B. Google Play.

Das Überprüfungsverfahren soll sicherstellen, dass alle Apps im App Store den Richtlinien von Apple für Qualität, Sicherheit und Inhalt entsprechen. Es kann jedoch aufgrund der langen Wartezeit eine Herausforderung sein und die Veröffentlichung Ihrer App verzögern.

Geschlossenes Ökosystem

Apple kontrolliert die Hardware und Software seiner Geräte streng, was bedeutet, dass nur von Apple zugelassene Software und Hardware mit iOS-Geräten verwendet werden kann. Ihr geschlossenes Ökosystem schränkt auch das Potenzial für Anpassungen ein und kann Barrieren schaffen, wenn Sie den Nutzern Ihrer App mehr Flexibilität bieten möchten.

Dieses geschlossene System wird es Entwicklern erschweren, Dienste und APIs von Drittanbietern zu integrieren.

Backend-Optionen für iOS-Anwendungen

Da Sie nun die Vorteile und Grenzen der Entwicklung von iOS-Anwendungen kennen, sollten Sie die verschiedenen Backend-Optionen für Ihre iOS-App verstehen.

IaaS

Infrastructure as a Service (IaaS) ist ein Cloud-Computing-Modell, bei dem ein Drittanbieter virtualisierte Rechenressourcen über das Internet für Benutzer anbietet, die diese für die Ausführung persönlicher Software benötigen.

Die Nutzung von IaaS ist wie das Mieten eines virtuellen Computers bei einem Drittanbieter. Anstatt einen Computer zu kaufen und zu lagern, können Sie auf einen Computer zugreifen, den der Anbieter über das Internet hostet.

Dieser Computer ist einfach ein virtuelles Abbild eines realen Computers mit der gesamten grundlegenden Infrastruktur, um Ihre eigene virtuelle Computerumgebung mit Funktionen wie Speicherplatz, Verarbeitungsleistung und Arbeitsspeicher aufzubauen.

Der Provider gewährt Ihnen Zugang zu diesem virtuellen Computer, auf dem Sie Ihre eigene Software und Anwendungen ausführen können, ohne sich um die physische Hardware oder die Wartung kümmern zu müssen.

Mit IaaS können Sie den Umfang je nach Bedarf vergrößern oder verkleinern und zahlen nur für das, was Sie nutzen. Beispiele für IaaS-Dienste sind Amazon Web Services (AWS), Microsoft Azure und Google Cloud Platform

PaaS

Platform as a Service (PaaS) ist ein weiteres Cloud-Computing-Modell, das mit IaaS vergleichbar ist. PaaS-Anbieter bieten eine vorkonfigurierte Plattform mit minimalen Anpassungen an, die es Ihnen erleichtert und beschleunigt, Anwendungen zu erstellen und einzusetzen.

Der Hauptunterschied zwischen IaaS und PaaS ist der Grad der Kontrolle, den Sie über die zugrunde liegende Infrastruktur haben.

Bei IaaS bietet der Anbieter virtualisierte Computerressourcen wie Server und Speicher über das Internet an. Gleichzeitig haben Sie die vollständige Kontrolle über die virtuelle Umgebung, einschließlich des Betriebssystems, der Middleware und der Anwendungen.

Bei PaaS hingegen bietet der Anbieter eine vorkonfigurierte Plattform für die Betriebssysteme, Middleware und andere Softwarekomponenten, die für die Entwicklung und Bereitstellung von Anwendungen benötigt werden. Sie müssen sich nur auf die Entwicklung der Anwendung konzentrieren, während sich der PaaS-Anbieter um die zugrunde liegende Infrastruktur kümmert.

Beispiele für PaaS-Dienste sind Heroku, Google App Engine und Microsoft Azure App Service.

BaaS

Mit Backend as a Service (BaaS) können Sie ganz einfach ein Cloud-Backend in Ihre Anwendung integrieren, ohne die zugrunde liegende Infrastruktur aufbauen oder verwalten zu müssen.

BaaS-Anbieter bieten vorgefertigte Backend-Dienste an, die in der Regel nicht mit PaaS oder IaaS bereitgestellt werden, z. B. Datenbanken, Benutzerauthentifizierung, Dateispeicher, serverlose Funktionen und Push-Benachrichtigungen. Sie können diese Dienste nun über eine API oder ein SDK in Ihre Anwendungen integrieren.

Dadurch müssen Sie keine eigene Backend-Infrastruktur aufbauen und pflegen und können sich auf die Entwicklung des Frontends der App konzentrieren. Beispiele für BaaS-Dienste sind Back4App, Firebase und 8Base.

Wie hoch sind die Kosten für die Entwicklung eines Backends für eine iOS-Anwendung?

Die Kosten für die Entwicklung eines Backends für eine iOS-App hängen von verschiedenen Faktoren ab, darunter Zeit, Ressourcen und Personal.

Der Zeitaufwand für den Aufbau und die Einrichtung des Backends ist ein wichtiger Faktor, der berücksichtigt werden muss. Die für den Aufbau des Backends benötigte Zeit hängt von der Komplexität der Funktionen der App und der Integration des Backends in die App ab.

Es kann auch zusätzliche Zeit für Tests, Fehlersuche und Bereitstellung erfordern. Je komplexer die Funktionen der App sind, desto länger kann die Entwicklung des Backends dauern, was letztlich die Kosten erhöht.

Die für die Entwicklung des Backends erforderlichen Humanressourcen sind ein weiterer entscheidender Faktor, der die Kosten beeinflusst. Die Einstellung und Bindung erfahrener Entwickler kann teuer sein, und die Kosten für Schulung und Entwicklung können die Gesamtkosten für die Entwicklung des Backends erhöhen.

Die Kosten für die Entwicklung eines Backends für eine iOS-App können durch die Nutzung bestehender Backend-Lösungen wie Back4app verwaltet werden.

Wie erstellt man ein iOS App Backend mit Back4app?

Back4App ist eine Backend-as-a-Service (BaaS)-Plattform mit einer vorgefertigten Backend-Infrastruktur für die Entwicklung von mobilen und Web-Apps. Sie bietet eine leistungsstarke und skalierbare Backend-Infrastruktur, einschließlich Datenbankmanagement, Benutzerauthentifizierung, Push-Benachrichtigungen und mehr.

Back4App ist aus mehreren Gründen eine hervorragende Option als Backend für Ihre iOS-App. Erstens bietet es eine einfache und benutzerfreundliche Schnittstelle, die die Verwaltung von Daten und APIs erleichtert.

Zweitens bietet es eine umfassende Dokumentation, die Sie durch jeden Schritt des Entwicklungsprozesses führt. Außerdem bietet Back4App skalierbares Cloud-Hosting, das den Anforderungen jeder App, ob groß oder klein, gerecht wird, und bietet hochwertige Sicherheitsfunktionen.

Wenn Sie die folgenden Schritte befolgen, können Sie mit Back4App ein iOS-App-Backend erstellen.

Schritt 1: Registrieren Sie sich für ein kostenloses Back4app-Konto

Um eine Backend-Infrastruktur für Ihre iOS-App zu erstellen, melden Sie sich für ein kostenloses Back4App-Konto auf der offiziellen Website an. Mit Ihrem Back4App-Konto haben Sie die Möglichkeit, Ihr Backend für Ihre iOS-App zu erstellen und zu konfigurieren und alle datenbezogenen Prozesse von dieser Backend-App aus zu verwalten.

Um sich für ein kostenloses Konto anzumelden, gehen Sie auf die Back4App-Website und melden Sie sich mit einem Google-Konto, einem GitHub-Konto oder einer E-Mail-Adresse an.

Schritt 2: Erstellen einer neuen App

Jetzt, wo Sie ein Back4App-Konto haben, können Sie sich einloggen und eine NEUE APP erstellen. Eine entsprechende Schaltfläche befindet sich in der oberen rechten Ecke Ihrer Kontoseite. Wählen Sie die Option Backend as a Service für Ihre App.

Geben Sie Ihrer neuen App einen passenden Namen und klicken Sie auf die Schaltfläche Erstellen.

Back4App erstellt nun Ihre App und leitet Sie zu seinem Dashboard weiter.

Schritt 3: Verbinden Sie Ihre iOS-App mit Back4app

Der nächste Schritt besteht darin, Ihre iOS-App mit Ihrem Back4App-Backend zu verbinden. Dazu müssen Sie das Parse SDK in Ihrer iOS-App installieren. Ihre App wird dieses SDK verwenden, um eine direkte Verbindung zum Backend herzustellen.

Bevor Sie die Verbindung einrichten können, benötigen Sie eine funktionierende iOS-Anwendung, mit der Sie arbeiten können. Wie bereits erwähnt, werden iOS-Anwendungen mit Xcode, der IDE von Apple für die Entwicklung von Apple-Software, erstellt.

Sie benötigen eine aktuelle Version von Xcode (Version 13.0.0 oder höher), die auf Ihrem Mac-Computer installiert ist, um dieser Anleitung folgen zu können. Einige der Werkzeuge und Funktionen, die Sie in dieser Anleitung verwenden werden, sind nur in diesen Versionen von Xcode verfügbar.

Starten Sie zunächst Xcode und erstellen Sie ein neues Xcode iOS App-Projekt:

Sie werden aufgefordert, einen Namen für Ihre Anwendung sowie einige Konfigurationsinformationen einzugeben. Stellen Sie sicher, dass Sie SwiftUI als bevorzugte Schnittstelle auswählen.

Die SwiftUI-Schnittstelle verwendet ein anderes Ansichtssystem als die auslaufende StoryBoard-Schnittstelle. Infolgedessen fehlt in Ihrer aktuellen Projektstruktur die Datei AppDelegate.swift. Sie müssen diese Datei erstellen, da Sie sie im weiteren Verlauf des Handbuchs benötigen werden.

Erstellen Sie AppDelegate.swift und importieren Sie den folgenden Code in die Datei:

import SwiftUI

class AppDelegate: NSObject, UIApplicationDelegate {
    
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
        return true 
    }
    
}

Kopieren Sie nun innerhalb von App in Ihrer Stamm-Projektdatei den folgenden Code und fügen Sie ihn am Anfang ein:

@UIApplicationDelegateAdaptor(AppDelegate.self) private var appDelegate

Jetzt können Sie das Parse SDK installieren. Sie werden es mit CocoaPods installieren, einem Open-Source-Abhängigkeitsmanager für Xcode-Projekte. Installieren Sie CocoaPods, wenn Sie es noch nicht getan haben.

Initialisieren Sie zunächst eine Poddatei für Ihr Projekt, indem Sie den Befehl pods init in einem Terminal in Ihrem Projektverzeichnis ausführen.

Öffnen Sie die generierte Poddatei mit Xcode und geben Sie das Parse SDK an.

Ihr Podfile sollte in etwa so aussehen:

# Uncomment the next line to define a global platform for your project
#platform :ios, '13.0'

target 'ParseiOS-app' do
  # Comment the next line if you don't want to use dynamic frameworks
  use_frameworks!

  # Pods for ParseiOS-app
  pod 'Parse'
  
end

Sie können dann das Parse SDK in Ihr Projekt mit der angegebenen Parse-Abhängigkeit im Podfile installieren.

Führen Sie den folgenden Befehl im Terminal aus:

pod install

Nach der Installation der Pods wird Ihr Projekt als neue Arbeitsbereichsdatei mit der Erweiterung .xcworkspace neu erstellt. Von hier an arbeiten Sie mit dem neu erstellten Arbeitsbereich.

Sie haben das Parse SDK erfolgreich in Ihrem Projekt installiert.

Möglicherweise tritt nach der Pod-Installation ein Kompatibilitätsfehler mit der iOS-Version des Simulators auf. Ändern Sie in diesem Fall Ihr Podfile, um dies am Ende einzufügen:

post_install do |installer|
  installer.generated_projects.each do |project|
    project.targets.each do |target|
      target.build_configurations.each do |config|
        config.build_settings['IPHONEOS_DEPLOYMENT_TARGET'] = '12.0'
      end
    end
  end
end

Das Codeschnipsel ist ein Post-Install-Hook für Ihr Podfile, mit dem Sie die Build-Einstellungen Ihres Xcode-Projekts ändern können, nachdem CocoaPods die Installation der Pods abgeschlossen hat.

Dieses spezielle Nachinstallationsprogramm setzt die minimale Zielversion für die Bereitstellung des iPhone OS auf 12.0. Sie können dies jederzeit ändern, indem Sie ['IPHONEOS_DEPLOYMENT_TARGET'] eine neue Version zuweisen.

Installieren Sie nun erneut Pods:

pod install

Um die Verbindung Ihrer iOS-App abzuschließen, müssen Sie die App-ID und den Client-Schlüssel Ihrer Back4App-App verknüpfen. Gehen Sie dazu zu den App-Einstellungen auf dem Dashboard und navigieren Sie zu Server-Einstellungen > Kerneinstellungen.

In den Grundeinstellungen sollten Sie die App-ID und den Client-Schlüssel finden, die Sie persönlich für Ihr Back4App-Backend generiert haben. Kopieren und speichern Sie diese Schlüssel.

Öffnen Sie anschließend AppDelegate.swift und ändern Sie den vorhandenen Code in der Funktion didFinishLaunchingWithOptions.

Ihre Funktion sollte folgendermaßen aussehen:

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
        print("app launched!")

        let configuration = ParseClientConfiguration {
    $0.applicationId = "PASTE_YOUR_APPLICATION_ID_HERE"
    $0.clientKey = "PASTE_YOUR_CLIENT_ID_HERE"
    $0.server = "<https://parseapi.back4app.com>"
}
Parse.initialize(with: configuration))

        return true
    }

Fügen Sie Ihre gespeicherte App-ID und den Client-Schlüssel in die angegebenen Platzhalter ein.

Anschließend sollten Sie das Parse-SDK in diese Datei importieren, um etwaige "Modul nicht gefunden" -Fehler zu beseitigen:

import Parse

Ihre App ist nun erfolgreich mit Back4App verbunden!

Schritt 4: Testen Sie Ihr Backend

In diesem Abschnitt werden Sie Ihre iOS-App testen, um zu bestätigen, dass Sie mit dem Back4App-Server und der von Ihnen erstellten App interagieren können.

Sie werden CRUD-Operationen testen und Daten mit dem Parse SDK speichern.

Am Ende des Tests können Sie bestätigen, dass die erstellten Daten erfolgreich gespeichert und von der Backend-App gelesen werden.

Um Daten im Backend zu speichern, erstellen Sie ein Klassenobjekt in Back4app. Standardmäßig wird eine neue Klasse ein Schema mit drei Feldern haben: “objectId”, “createdAt”, und “updatedAt”. Sie können neue Felder und Datenzeilen hinzufügen.

Sie werden ein neues Feld in Ihrer iOS-App erstellen und die in Ihrer erstellten Klasse gespeicherten Daten lesen.

Zuerst importieren Sie in ContentView.swift das Parse SDK direkt unter SwiftUI:

import SwiftUI
import Parse

Um zu testen, ob Ihre App mit dem Backend interagieren kann, werden Sie eine Benutzeroberfläche erstellen, über die ein Benutzer einen Text eingeben kann, der im Backend gespeichert wird. Die App wird auch in der Lage sein, auf das Backend zuzugreifen, Daten aus Ihrer Klasse abzufragen und die gespeicherten Punktzahlen anzuzeigen.

Legen Sie oben in der View-Struktur in ContentView.swift die folgenden veränderbaren Zustandseigenschaften an:

@State private var newScore: Int = ""
@State private var scores: [PFObject] = []

Diese Statuseigenschaften lösen Aktualisierungen der Ansicht aus, wenn sich ihre Werte ändern. Die erste deklariert eine Statuseigenschaft namens newScore vom Typ String. Sie stellt den Eingabewert dar, den der Benutzer für eine neue Punktzahl eingegeben hat. Sie wird mit einer leeren Zeichenkette "" initialisiert.

Die zweite deklariert eine Statuseigenschaft namens scores vom Typ [PFObject], die ein Array von PFObject-Instanzen ist. Dieses Array repräsentiert die vom Backend abgerufenen Punktzahlen.

Die PFObject-Klasse ist ein Klassenobjekt, das von Parse-SDK-iOS bereitgestellt wird und Daten speichern kann. Sie ermöglicht es Ihnen, benutzerdefinierte Eigenschaften und Werte für Ihre Objekte zu definieren, die dann im Backend gespeichert werden können.

Fügen Sie dann innerhalb eines VStack-Elements den folgenden Codeausschnitt ein:

VStack {
  TextField("EnterScore", text: $newScore)
    .textFieldStyle(RoundedBorderTextFieldStyle())
    .padding()
  Button("Save Scores") {
    saveScore()
  }

  List(scores, id: \\.objectId) { score in
    Text(score["score"] as? String ?? "")
  }
}
.padding()
.onAppear {
  fetchScores()
}

Sie haben ein TextField, in das die Benutzer eine Punktzahl eingeben. Der Text-Parameter ist an die Zustandsvariable newScore gebunden, d. h., alle Änderungen im Textfeld werden in der Variablen newScore wiedergegeben.

Als nächstes gibt es eine Schaltfläche “Spielstand speichern”, die eine saveScore() -Funktion auslöst, wenn sie angetippt wird.

Die Komponente Liste zeigt die vom Backend abgerufenen Ergebnisse an. Sie verwenden das Scores-Array, um die Liste aufzufüllen, und der id-Parameter gibt einen eindeutigen Bezeichner für jedes Score-Element an. Innerhalb der Liste gibt es eine Textansicht, die den Punktwert als String anzeigt.

Sie verwenden die optionale Verkettung und den Null-Koaleszenz-Operator (??), um Fälle zu behandeln, in denen die Partitur nicht verfügbar ist oder von einem anderen Typ ist.

Schließlich wird der onAppear-Modifikator verwendet, um die Funktion fetchScores() auszulösen, wenn die VStack-Ansicht erscheint.

Zu diesem Zeitpunkt sollten Sie eine Fehlermeldung erhalten, dass saveScores() und fetchScores() nicht gefunden werden können.

Sie werden diese Funktionen als nächstes erstellen. Diese Funktionen werden das Schreiben, Speichern von Daten und das Abrufen dieser gespeicherten Daten von Ihrer verknüpften Back4app-Backend-App behandeln.

Verwenden Sie den Aufruf der Methode .save() oder saveInBackground(), um die Variable newScore im Backend zu speichern:

func saveScore() {
  let score = PFObject(className: "GameScore")
  score["score"] = newScore

  score.saveInBackground { success, error in
    if let error = error {
      print("Error saving score: \\(error.localizedDescription)")
    } else {
      print("Score saved sucessfully: \\(String(describing: score.objectId))")
      newScore = ""
      fetchScores()
    }

  }
}

Zunächst erstellen Sie eine neue Instanz von PFObject mit dem Klassennamen “GameScore”. Dieses Objekt stellt einen neuen Eintrag in der Backend-Datenbank dar. In der nächsten Zeile setzen Sie die Eigenschaft “score” des Objekts auf den in newScore gespeicherten Wert.

Als Nächstes rufen Sie die Methode saveInBackground für das Score-Objekt auf. Mit saveInBackground wird ein asynchroner Speichervorgang gestartet, der in einer Warteschlange im Hintergrund ausgeführt wird. Innerhalb der Abschluss-Schließung prüfen Sie, ob während des Speichervorgangs ein Fehler aufgetreten ist, und behandeln den Fehler.

Nach dem erfolgreichen Speichern des Ergebnisses setzen Sie die Statusvariable newScore auf einen leeren String zurück, um das Textfeld zu löschen. Rufen Sie dann die Funktion fetchScores() auf, um die Liste der Spielstände zu aktualisieren.

In der Funktion fetchScores() verwenden Sie die PFQuery von Parse, um Abfragen auf Ihren Backend-Daten durchzuführen und Objekte aus einer bestimmten Klasse abzurufen. In diesem Fall ist diese Klasse die GameScore-Klasse:

func fetchScores() {
  let query = PFQuery(className: "GameScore")
  query.findObjectsInBackground { objects, error in
    if let error = error {
      print("Error fetching scores: \\(error.localizedDescription)")
    } else if let objects = objects {
      scores = objects
    }

  }
}

Hier rufen Sie die findObjectsInBackground-Methode für das Abfrageobjekt auf, um den asynchronen Abrufvorgang einzuleiten. Innerhalb der Abschluss-Schließung können Sie die Ergebnisse dieser Abfrage verarbeiten.

Tritt während des Abrufvorgangs ein Fehler auf, wird eine Fehlermeldung ausgegeben. Andernfalls, wenn der Abruf erfolgreich war und Objekte zurückgegeben werden, aktualisieren Sie die Statusvariable scores mit den abgerufenen Objekten. Diese Objekte stellen die vom Backend abgerufenen Werte dar.

Wenn Sie Ihre App starten, einen neuen Spielstand eingeben und auf die Schaltfläche Spielstand speichern klicken, sendet und speichert die App Ihren neuen Spielstand an das Backend und ruft alle gespeicherten Spielstände ab. Es sollte dann eine Liste der Punktestände wie in der Abbildung unten angezeigt werden.

Beachten Sie, dass die Punktzahlen mit den Punktwerten in Ihrem Backend übereinstimmen.

Dies bestätigt, dass der Test bestanden wurde und Sie erfolgreich Daten aus dem Back4App-Backend schreiben und lesen.

Sie wissen jetzt, wie Sie mit Back4App und der Programmiersprache Swift ein Backend für Ihre mobilen iOS-Apps erstellen können.