iOS Vorlage

Todo-App-Backend-Vorlage
iOS — Schema, API & KI-Leitfaden

Ein produktionsbereites iOS Todo Backend-Schema und Starter Kit auf Back4app: ER-Diagramm, Datenwörterbuch, JSON-Schema, API-Spielplatz, Codebeispiele und ein One-Click KI-Agent Prompt zur Bereitstellung in Minuten.

Wichtige Erkenntnisse

Auf dieser Seite erhalten Sie ein produktionsbereites Schema, einen KI-Prompt mit einem Klick und Schritt-für-Schritt iOS-Code — damit Sie eine Todo-App ohne Backend-Entwicklung bereitstellen können.

  1. In Minuten bereitstellenFügen Sie den KI-Agenten-Prompt ein und erhalten Sie eine laufende App mit Frontend, Backend und Datenbank.
  2. Standardmäßig sicherZeilenebene-ACLs stellen sicher, dass jeder Benutzer nur seine eigenen Todos sieht.
  3. iOS-native SDKtypisierte Objekte, async/await, Offline-Pinning und Live Queries sofort einsatzbereit.
  4. REST + GraphQLbeide APIs werden automatisch generiert; keine benutzerdefinierten Endpunkte zu schreiben.
  5. Zwei Klassen_User (eingebaute Authentifizierung) und Todo (Aufgaben mit Titel, erledigt, Fälligkeitsdatum, Priorität, Besitzer).

Was ist die iOS Todo-App-Backend-Vorlage?

Back4app ist ein Backend-as-a-Service (BaaS), das sich ideal für Todo-Apps eignet: verwaltetes Backend, Authentifizierung, Echtzeit und SDKs für über 13 Technologien. Die iOS Todo App Backend-Vorlage ist ein vorgefertigtes, produktionsbereites Backend-Schema, das auf Back4app gehostet wird. Es bietet Ihnen zwei Datenbankklassen (_User und Todo), besitzbasierte ACLs, REST- und GraphQL-APIs sowie einen Ein-Klick-AI-Agenten-Prompt — sodass Sie ein iOS-Frontend verbinden und eine funktionierende Todo-App in Minuten statt in Tagen bereitstellen können.

Am besten geeignet für:

App-EntwicklerSchnelles PrototypingHackathonsBackend-Entwicklung lernenMVP-StartsTeams, die sich für ein BaaS anstelle eines benutzerdefinierten Backends entscheiden

Übersicht

Eine Todo-App ist einer der häufigsten Ausgangspunkte zum Lernen der Backend-Entwicklung. Im Hintergrund benötigt sie Benutzerregistrierung, Aufgaben-CRUD, besitzbasierte Zugriffskontrolle und optional Echtzeitsynchronisation.

Das folgende Schema definiert zwei Klassen — _User (integriert) und Todo — die durch einen Pointer verbunden sind. Mit dem Back4app iOS SDK können Sie von Ihrer App aus mit diesem Backend interagieren — Abfragen, Erstellen, Aktualisieren und Löschen von Objekten — ohne eine benutzerdefinierte API-Schicht zu schreiben.

Warum Ihr iOS Todo-Backend mit Back4app erstellen?

Back4app bietet Ihnen ein fertiges Backend und ein typisiertes SDK, damit Sie Ihre Todo-App erstellen können, ohne REST-Glue zu schreiben oder die Authentifizierung selbst zu verwalten.

  • SDK & Typsicherheit: Das SDK hält Todo und Benutzer typsicher und verarbeitet JSON, sodass Sie weniger Boilerplate schreiben.
  • Async & optionale Offline: Verwenden Sie async/await; unterstützte SDKs bieten lokale Speicherung, sodass Ihre Liste offline funktioniert und beim Online-Sein synchronisiert wird.
  • Live Queries: Abonnieren Sie Änderungen an Todo, damit die UI in Echtzeit über WebSockets aktualisiert wird.

Das gleiche Schema und die gleichen APIs für jeden Stack — wechseln Sie später die Clients, ohne das Backend zu ändern.

Kernvorteile

Ein produktionsbereites Todo-Backend, damit Sie schneller liefern und sich auf Ihre App konzentrieren können.

Schneller liefern, kein Backend-Code

REST- und GraphQL-APIs sowie ein einsatzbereites Schema — verbinden Sie Ihre App und legen Sie los.

Standardmäßig sicher

ACLs und Berechtigungen auf Klassenebene, damit Benutzer nur auf ihre eigenen Daten zugreifen können.

Echtzeit-Updates

Live Queries über WebSockets für sofortige UI-Updates.

Integrierte Authentifizierung

Benutzerregistrierung, -anmeldung und Sitzungsverwaltung sofort einsatzbereit — keine benutzerdefinierte Authentifizierungsschicht.

Funktioniert offline

Lokales Pinnen hält Daten offline verfügbar und synchronisiert, wenn Sie sich wieder verbinden.

In Minuten bereitstellen

Verwenden Sie den KI-Agenten, um Ihre Todo-App aus dieser Vorlage zu erstellen und bereitzustellen.

Bereit, es auszuprobieren?

Lassen Sie den Back4app KI-Agenten das Backend Ihrer Todo-App erstellen, das iOS-Frontend verbinden und bereitstellen — alles aus einem einzigen Prompt.

Kostenlos starten — 50 KI-Agenten-Prompts/Monat, keine Kreditkarte erforderlich

Technologiestack

Alles, was diese Todo-App-Vorlage auf einen Blick antreibt.

Frontend
iOS
Backend
Back4app
Datenbank
MongoDB
Auth
Auth & Zugriffskontrolle
APIs
REST & GraphQL
Bereitstellung
KI-Agent / Dashboard

ER-Diagramm

Entity-Relationship-Diagramm für das iOS Todo-App-Datenmodell.

Diagrammquelle anzeigen
Mermaid
erDiagram
    _User {
        String objectId PK
        String username
        String email
        String password
        Date createdAt
        Date updatedAt
    }

    Todo {
        String objectId PK
        String title
        Boolean done
        Date dueDate
        Number priority
        Pointer owner FK
        Date createdAt
        Date updatedAt
    }

    _User ||--o{ Todo : "owns"

Integrationsfluss

Auth-to-CRUD-Sequenz: wie Ihre iOS-App mit Back4app kommuniziert — anmelden, dann Todos abfragen und erstellen.

Diagrammquelle anzeigen
Mermaid
sequenceDiagram
  participant User
  participant App as iOS App
  participant Back4app as Back4app Cloud

  User->>App: Login
  App->>Back4app: ParseUser.logIn(username:password:)
  Back4app-->>App: Session token
  App-->>User: Logged in

  User->>App: Load todos
  App->>Back4app: ParseQuery.find()
  Back4app-->>App: [PFObject]
  App-->>User: Show list

  User->>App: Create todo
  App->>Back4app: todo.save()
  Back4app-->>App: Todo (objectId)
  App-->>User: Updated list

Datenwörterbuch

Vollständige Feldreferenz für jede Klasse im Schema.

FeldTypBeschreibungErforderlich
objectIdStringAuto-generated unique identifierauto
titleStringShort description of the task
doneBooleanWhether the task is completed
dueDateDateOptional deadline for the task
priorityNumberPriority level (1 = high, 3 = low)
ownerPointer<_User>User who owns this task
createdAtDateAuto-generated creation timestampauto
updatedAtDateAuto-generated last-update timestampauto

8-Felder in Todo

Sicherheit & Berechtigungen

Wie Eigentum, ACLs und Klassenberechtigungen Daten in diesem Schema schützen.

Zeilenebene ACLs

Jede Todo erhält eine ACL, die mit ihrem Eigentümer verknüpft ist. Nur der Ersteller kann seine eigenen Aufgaben lesen, aktualisieren oder löschen.

Klassenberechtigungen

CLPs beschränken, welche Rollen oder Benutzer Objekte auf Klassenebene erstellen, lesen, aktualisieren oder löschen können — Ihre erste Verteidigungslinie.

Zeigerbasiertes Eigentum

Der Eigentümer-Zeiger verknüpft jedes Todo mit seinem _User. Cloud Code-Trigger können das Eigentum automatisch festlegen und ACLs beim Speichern durchsetzen.

Schema (JSON)

Rohes JSON-Schema-Definition — kopieren und in Ihrer Back4app-App verwenden oder über die API importieren.

JSON
{
  "classes": [
    {
      "className": "Todo",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "title": {
          "type": "String",
          "required": true
        },
        "done": {
          "type": "Boolean",
          "required": false,
          "defaultValue": false
        },
        "dueDate": {
          "type": "Date",
          "required": false
        },
        "priority": {
          "type": "Number",
          "required": false,
          "defaultValue": 3
        },
        "owner": {
          "type": "Pointer",
          "targetClass": "_User",
          "required": false
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    },
    {
      "className": "_User",
      "fields": {
        "objectId": {
          "type": "String",
          "required": false
        },
        "username": {
          "type": "String",
          "required": true
        },
        "email": {
          "type": "String",
          "required": true
        },
        "password": {
          "type": "String",
          "required": true
        },
        "createdAt": {
          "type": "Date",
          "required": false
        },
        "updatedAt": {
          "type": "Date",
          "required": false
        }
      }
    }
  ]
}

Mit AI-Agent bauen

Verwenden Sie den Back4app AI-Agent, um eine echte Todo-App aus dieser Vorlage zu erstellen: Er wird das Frontend, das Backend (dieses Schema, Authentifizierung und APIs) erstellen und bereitstellen — keine manuelle Einrichtung. Die folgende Eingabeaufforderung beschreibt diesen Todo-Stack, damit der Agent eine produktionsbereite App in einem Rutsch generieren kann.

Back4app AI-Agent
Bereit zum Bauen
Erstellen Sie eine Todo-App auf Back4app mit diesem genauen Schema und Verhalten.

Schema:
1. _User (verwenden Sie die integrierte Back4app): Benutzername (String, erforderlich), E-Mail (String, erforderlich), Passwort (String, erforderlich); objectId, createdAt, updatedAt (System).
2. Todo: Titel (String, erforderlich), erledigt (Boolean, Standard: false), Fälligkeitsdatum (Date, optional), Priorität (Number, Standard: 3; 1=hoch, 2=mittel, 3=niedrig), Eigentümer (Pointer zu _User; beim Erstellen auf aktuellen Benutzer setzen); objectId, createdAt, updatedAt (System).

Sicherheit:
- Setzen Sie ACLs für jedes Todo, sodass nur der Eigentümer lesen und schreiben kann. Kein öffentlicher Lese-/Schreibzugriff.
- Beim Erstellen setzen Sie Todo.owner auf den aktuellen Benutzer (z. B. über Cloud Code beforeSave oder clientseitig).
- Verwenden Sie Klassenebenenberechtigungen, damit nur authentifizierte Benutzer Todo erstellen/lesen/aktualisieren/löschen können.

Auth:
- Registrierung (Benutzername, E-Mail, Passwort) und Anmeldung; Unterstützung für Abmeldung/Sitzung.
- Nach der Anmeldung sollte die App nur CRUD für die Todos des aktuellen Benutzers anzeigen und erlauben.

Verhalten:
- Vollständiges CRUD für Todo: erstellen, auflisten (nur des Eigentümers), eines abrufen, aktualisieren (erledigt umschalten, Titel, Fälligkeitsdatum, Priorität bearbeiten), löschen.
- Todos mit Sortierung auflisten (z. B. nach Priorität dann Fälligkeitsdatum oder createdAt). Standardpriorität für neue Todos: 3 (niedrig).

Lieferung:
- Erstellen Sie die Back4app-App mit dem obigen Schema, ACLs und allen benötigten Cloud Codes (z. B. beforeSave auf Todo, um den Eigentümer festzulegen).
- Generieren Sie das Frontend und verbinden Sie es mit diesem Backend; bereitstellen, damit die App end-to-end lauffähig ist.

Drücken Sie die Schaltfläche unten, um den Agenten mit der vorab ausgefüllten Eingabeaufforderung dieser Vorlage zu öffnen.

In Minuten bereitstellen50 kostenlose Prompts / MonatKeine Kreditkarte erforderlich

API Playground

Testen Sie die REST- und GraphQL-Endpunkte für das Todo-Schema. Antworten aus den obigen Beispieldaten — kein Back4app-Konto erforderlich.

Playground wird geladen…

Verwendet dasselbe Todo-Schema wie diese Vorlage.

Schritt-für-Schritt iOS Integration

Verbinden Sie sich von einer iOS App mit Ihrem Back4app Backend unter Verwendung des Back4app iOS SDK.

  1. Schritt 1: Installieren Sie das Back4app iOS SDK

    Fügen Sie das Back4app SDK für Ihren Stack hinzu (z.B. npm, pubspec oder Paketmanager).

    Swift
    // Package.swift or CocoaPods
    // SPM: .package(url: "https://github.com/parse-community/Parse-Swift", from: "4.0.0")
    // Podfile: pod 'Parse'
  2. Schritt 2: Initialisieren Sie Back4app in Ihrer App

    Initialisieren Sie das Back4app SDK beim Start der App mit Ihrer App-ID und der Server-URL.

    Swift
    Parse.initialize(
        configuration: ParseClientConfiguration {
            $0.applicationId = "YOUR_APP_ID"
            $0.clientKey = "YOUR_CLIENT_KEY"
            $0.server = "https://parseapi.back4app.com/"
        }
    )
  3. Schritt 3: Alle Todos abfragen

    Verwenden Sie das SDK, um alle Todo-Objekte nach Priorität abzurufen.

    Swift
    func getTodos() async throws -> [PFObject] {
        let query = PFQuery(className: "Todo")
        query.order(byAscending: "priority")
        return try await query.findObjects()
    }
  4. Schritt 4: Erstellen Sie ein Todo

    Erstellen Sie ein neues Todo mit Titel, erledigt und Priorität und speichern Sie es.

    Swift
    func createTodo(title: String, priority: Int = 3) async throws {
        let todo = PFObject(className: "Todo")
        todo["title"] = title
        todo["done"] = false
        todo["priority"] = priority
        try await todo.save()
    }
  5. Schritt 5: Todos aktualisieren und löschen

    Felder aktualisieren und speichern oder das Objekt löschen.

    Swift
    // Mark done
    func markDone(objectId: String) async throws {
        let query = PFQuery(className: "Todo")
        let todo = try await query.getObjectWithId(objectId)
        todo["done"] = true
        try await todo.save()
    }
    
    // Delete
    func deleteTodo(objectId: String) async throws {
        let query = PFQuery(className: "Todo")
        let todo = try await query.getObjectWithId(objectId)
        try await todo.delete()
    }

Integration des Zustandsmanagements

Integrieren Sie das Back4app SDK mit der Zustandschicht Ihrer App (z. B. Kontext, Speicher oder Dienste).

Vollständiges Datenmodell

Kopieren Sie ein vollständiges Todo-Modell für typsichere Serialisierung (z. B. Klasse, Schnittstelle oder Typdefinition).

Swift
// Todo.swift — matches Back4app schema
struct Todo: Codable {
    var objectId: String?
    var title: String
    var done: Bool
    var dueDate: Date?
    var priority: Int
    var owner: Pointer<_User>?
    var createdAt: Date?
    var updatedAt: Date?
}

func toTodo(_ obj: PFObject) -> Todo {
    Todo(
        objectId: obj.objectId,
        title: obj["title"] as? String ?? "",
        done: obj["done"] as? Bool ?? false,
        dueDate: obj["dueDate"] as? Date,
        priority: obj["priority"] as? Int ?? 3,
        owner: obj["owner"] as? Pointer<_User>,
        createdAt: obj.createdAt,
        updatedAt: obj.updatedAt
    )
}

Offline-First & Lokaler Datenspeicher

Verwenden Sie pin() und unpin(), damit Daten offline verfügbar sind und synchronisiert werden, wenn Sie wieder online sind.

Unterstützte SDKs umfassen einen lokalen Datenspeicher. Pin Sie Todo-Objekte (oder die gesamte Klasse), um sie auf dem Gerät zu behalten; Abfragen Sie die gepinnten Daten, wenn Sie offline sind. Wenn die App wieder online ist, synchronisieren Sie mit dem Server.

Unten: Ergebnisse nach dem Abrufen pinnen und unpinnen, wenn Sie lokale Kopien nicht mehr benötigen.

Swift
// After fetch, pin for offline
try? await PFObject.pinAll(todos)

// Query from local datastore
let query = PFQuery(className: "Todo").fromLocalDatastore()
query.order(byAscending: "priority")
let localTodos = try? await query.findObjects()

// Unpin
try? await PFObject.unpinAllObjects(inBackground: "Todo")

Häufig gestellte Fragen

Häufige Fragen zum Backend-Template der Todo-App.

Was ist Back4app?
Warum Back4app für eine iOS Todo-App verwenden?
Was ist die Todo-Klasse in einer iOS Todo-App?
Wie funktioniert das Eigentum mit dem iOS SDK?
Kann ich später Felder zu Todo in meiner iOS App hinzufügen?
Wie frage ich Todos nach Priorität in Swift ab?
Unterstützt das iOS SDK Offline-Todo-Listen?
Wie füge ich Kategorien oder Tags in iOS hinzu?

Von Entwicklern weltweit vertraut

Treten Sie der Community bei, die die Zukunft von Apps gestaltet

G2 Users Love Us Badge

Bereit, Ihre Todo-App zu erstellen?

Starten Sie Ihr iOS-Projekt in wenigen Minuten. Keine Kreditkarte erforderlich.

Bauen mit KI-Agenten